mirror of
https://github.com/Finesssee/ProxyPilot.git
synced 2026-11-19 02:17:46 +00:00
1950 lines
64 KiB
Go
1950 lines
64 KiB
Go
// Package executor provides runtime execution capabilities for various AI service providers.
|
|
// This file implements the Antigravity executor that proxies requests to the antigravity
|
|
// upstream using OAuth credentials.
|
|
package executor
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"math/rand"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/agentdebug"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/memory"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/registry"
|
|
"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
|
|
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
|
|
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor"
|
|
sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator"
|
|
log "github.com/sirupsen/logrus"
|
|
"github.com/tidwall/gjson"
|
|
"github.com/tidwall/sjson"
|
|
)
|
|
|
|
const (
|
|
antigravityBaseURLDaily = "https://daily-cloudcode-pa.googleapis.com"
|
|
antigravitySandboxBaseURLDaily = "https://daily-cloudcode-pa.sandbox.googleapis.com"
|
|
antigravityBaseURLProd = "https://cloudcode-pa.googleapis.com"
|
|
antigravityCountTokensPath = "/v1internal:countTokens"
|
|
antigravityStreamPath = "/v1internal:streamGenerateContent"
|
|
antigravityGeneratePath = "/v1internal:generateContent"
|
|
antigravityModelsPath = "/v1internal:fetchAvailableModels"
|
|
antigravityClientID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com"
|
|
antigravityClientSecret = "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"
|
|
defaultAntigravityAgent = "antigravity/1.104.0 darwin/arm64"
|
|
antigravityAuthType = "antigravity"
|
|
refreshSkew = 3000 * time.Second
|
|
)
|
|
|
|
var (
|
|
randSource = rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
randSourceMutex sync.Mutex
|
|
)
|
|
|
|
// AntigravityExecutor proxies requests to the antigravity upstream.
|
|
type AntigravityExecutor struct {
|
|
cfg *config.Config
|
|
}
|
|
|
|
// NewAntigravityExecutor creates a new Antigravity executor instance.
|
|
//
|
|
// Parameters:
|
|
// - cfg: The application configuration
|
|
//
|
|
// Returns:
|
|
// - *AntigravityExecutor: A new Antigravity executor instance
|
|
func NewAntigravityExecutor(cfg *config.Config) *AntigravityExecutor {
|
|
return &AntigravityExecutor{cfg: cfg}
|
|
}
|
|
|
|
// Identifier returns the executor identifier.
|
|
func (e *AntigravityExecutor) Identifier() string { return antigravityAuthType }
|
|
|
|
// PrepareRequest prepares the HTTP request for execution (no-op for Antigravity).
|
|
func (e *AntigravityExecutor) PrepareRequest(_ *http.Request, _ *cliproxyauth.Auth) error { return nil }
|
|
|
|
// Execute performs a non-streaming request to the Antigravity API.
|
|
func (e *AntigravityExecutor) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
|
|
if strings.Contains(req.Model, "claude") {
|
|
return e.executeClaudeNonStream(ctx, auth, req, opts)
|
|
}
|
|
|
|
token, updatedAuth, errToken := e.ensureAccessToken(ctx, auth)
|
|
if errToken != nil {
|
|
return resp, errToken
|
|
}
|
|
if updatedAuth != nil {
|
|
auth = updatedAuth
|
|
}
|
|
|
|
reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
|
|
defer reporter.trackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
to := sdktranslator.FromString("antigravity")
|
|
translated := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), false)
|
|
|
|
translated = applyThinkingMetadataCLI(translated, req.Metadata, req.Model)
|
|
translated = util.ApplyGemini3ThinkingLevelFromMetadataCLI(req.Model, req.Metadata, translated)
|
|
translated = util.ApplyDefaultThinkingIfNeededCLI(req.Model, translated)
|
|
translated = normalizeAntigravityThinking(req.Model, translated)
|
|
translated = applyPayloadConfigWithRoot(e.cfg, req.Model, "antigravity", "request", translated)
|
|
|
|
baseURLs := antigravityBaseURLFallbackOrder(auth)
|
|
httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
|
|
var lastStatus int
|
|
var lastBody []byte
|
|
var lastErr error
|
|
|
|
for idx, baseURL := range baseURLs {
|
|
httpReq, errReq := e.buildRequest(ctx, auth, token, req.Model, translated, false, opts.Alt, baseURL)
|
|
if errReq != nil {
|
|
err = errReq
|
|
return resp, err
|
|
}
|
|
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errDo)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errDo
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
err = errDo
|
|
return resp, err
|
|
}
|
|
|
|
recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
if errRead != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errRead)
|
|
err = errRead
|
|
return resp, err
|
|
}
|
|
appendAPIResponseChunk(ctx, e.cfg, bodyBytes)
|
|
|
|
if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices {
|
|
log.Debugf("antigravity executor: upstream error status: %d, body: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), bodyBytes))
|
|
lastStatus = httpResp.StatusCode
|
|
lastBody = append([]byte(nil), bodyBytes...)
|
|
lastErr = nil
|
|
if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
retryAfter := antigravityRetryAfter(httpResp.StatusCode, httpResp.Header, bodyBytes)
|
|
err = statusErr{code: httpResp.StatusCode, msg: formatErrorMessage(bodyBytes, auth), retryAfter: retryAfter}
|
|
return resp, err
|
|
}
|
|
|
|
reporter.publish(ctx, parseAntigravityUsage(bodyBytes))
|
|
var param any
|
|
converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bodyBytes, ¶m)
|
|
resp = cliproxyexecutor.Response{Payload: []byte(converted)}
|
|
// #region agent log
|
|
agentdebug.Log(
|
|
"H1",
|
|
"internal/runtime/executor/antigravity_executor.go:Execute:nonstream_done",
|
|
"nonstream_payload_sizes",
|
|
map[string]any{
|
|
"model": req.Model,
|
|
"reqPayloadBytes": len(req.Payload),
|
|
"translatedBytes": len(translated),
|
|
"respBytes": len(resp.Payload),
|
|
},
|
|
)
|
|
// #endregion agent log
|
|
reporter.ensurePublished(ctx)
|
|
return resp, nil
|
|
}
|
|
|
|
switch {
|
|
case lastStatus != 0:
|
|
err = statusErr{code: lastStatus, msg: formatErrorMessage(lastBody, auth)}
|
|
case lastErr != nil:
|
|
err = lastErr
|
|
default:
|
|
err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"}
|
|
}
|
|
return resp, err
|
|
}
|
|
|
|
// executeClaudeNonStream performs a claude non-streaming request to the Antigravity API.
|
|
func (e *AntigravityExecutor) executeClaudeNonStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
|
|
token, updatedAuth, errToken := e.ensureAccessToken(ctx, auth)
|
|
if errToken != nil {
|
|
return resp, errToken
|
|
}
|
|
if updatedAuth != nil {
|
|
auth = updatedAuth
|
|
}
|
|
|
|
reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
|
|
defer reporter.trackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
to := sdktranslator.FromString("antigravity")
|
|
translated := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true)
|
|
|
|
translated = applyThinkingMetadataCLI(translated, req.Metadata, req.Model)
|
|
translated = util.ApplyGemini3ThinkingLevelFromMetadataCLI(req.Model, req.Metadata, translated)
|
|
translated = util.ApplyDefaultThinkingIfNeededCLI(req.Model, translated)
|
|
translated = normalizeAntigravityThinking(req.Model, translated)
|
|
translated = applyPayloadConfigWithRoot(e.cfg, req.Model, "antigravity", "request", translated)
|
|
|
|
baseURLs := antigravityBaseURLFallbackOrder(auth)
|
|
httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
|
|
var lastStatus int
|
|
var lastBody []byte
|
|
var lastErr error
|
|
|
|
for idx, baseURL := range baseURLs {
|
|
httpReq, errReq := e.buildRequest(ctx, auth, token, req.Model, translated, true, opts.Alt, baseURL)
|
|
if errReq != nil {
|
|
err = errReq
|
|
return resp, err
|
|
}
|
|
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errDo)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errDo
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
err = errDo
|
|
return resp, err
|
|
}
|
|
recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices {
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
if errRead != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errRead)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errRead
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
err = errRead
|
|
return resp, err
|
|
}
|
|
appendAPIResponseChunk(ctx, e.cfg, bodyBytes)
|
|
lastStatus = httpResp.StatusCode
|
|
lastBody = append([]byte(nil), bodyBytes...)
|
|
lastErr = nil
|
|
if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
retryAfter := antigravityRetryAfter(httpResp.StatusCode, httpResp.Header, bodyBytes)
|
|
err = statusErr{code: httpResp.StatusCode, msg: string(bodyBytes), retryAfter: retryAfter}
|
|
return resp, err
|
|
}
|
|
|
|
out := make(chan cliproxyexecutor.StreamChunk)
|
|
go func(resp *http.Response) {
|
|
defer close(out)
|
|
defer func() {
|
|
if errClose := resp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
scanner := bufio.NewScanner(resp.Body)
|
|
scanner.Buffer(nil, streamScannerBuffer)
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
appendAPIResponseChunk(ctx, e.cfg, line)
|
|
|
|
// Filter usage metadata for all models
|
|
// Only retain usage statistics in the terminal chunk
|
|
line = FilterSSEUsageMetadata(line)
|
|
|
|
payload := jsonPayload(line)
|
|
if payload == nil {
|
|
continue
|
|
}
|
|
|
|
if detail, ok := parseAntigravityStreamUsage(payload); ok {
|
|
reporter.publish(ctx, detail)
|
|
}
|
|
|
|
out <- cliproxyexecutor.StreamChunk{Payload: payload}
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errScan)
|
|
reporter.publishFailure(ctx)
|
|
out <- cliproxyexecutor.StreamChunk{Err: errScan}
|
|
} else {
|
|
reporter.ensurePublished(ctx)
|
|
}
|
|
}(httpResp)
|
|
|
|
var buffer bytes.Buffer
|
|
for chunk := range out {
|
|
if chunk.Err != nil {
|
|
return resp, chunk.Err
|
|
}
|
|
if len(chunk.Payload) > 0 {
|
|
_, _ = buffer.Write(chunk.Payload)
|
|
_, _ = buffer.Write([]byte("\n"))
|
|
}
|
|
}
|
|
resp = cliproxyexecutor.Response{Payload: e.convertStreamToNonStream(buffer.Bytes())}
|
|
|
|
reporter.publish(ctx, parseAntigravityUsage(resp.Payload))
|
|
var param any
|
|
converted := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, resp.Payload, ¶m)
|
|
resp = cliproxyexecutor.Response{Payload: []byte(converted)}
|
|
reporter.ensurePublished(ctx)
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
switch {
|
|
case lastStatus != 0:
|
|
err = statusErr{code: lastStatus, msg: string(lastBody)}
|
|
case lastErr != nil:
|
|
err = lastErr
|
|
default:
|
|
err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"}
|
|
}
|
|
return resp, err
|
|
}
|
|
|
|
func (e *AntigravityExecutor) convertStreamToNonStream(stream []byte) []byte {
|
|
responseTemplate := ""
|
|
var traceID string
|
|
var finishReason string
|
|
var modelVersion string
|
|
var responseID string
|
|
var role string
|
|
var usageRaw string
|
|
parts := make([]map[string]interface{}, 0)
|
|
var pendingKind string
|
|
var pendingText strings.Builder
|
|
var pendingThoughtSig string
|
|
|
|
flushPending := func() {
|
|
if pendingKind == "" {
|
|
return
|
|
}
|
|
text := pendingText.String()
|
|
switch pendingKind {
|
|
case "text":
|
|
if strings.TrimSpace(text) == "" {
|
|
pendingKind = ""
|
|
pendingText.Reset()
|
|
pendingThoughtSig = ""
|
|
return
|
|
}
|
|
parts = append(parts, map[string]interface{}{"text": text})
|
|
case "thought":
|
|
if strings.TrimSpace(text) == "" && pendingThoughtSig == "" {
|
|
pendingKind = ""
|
|
pendingText.Reset()
|
|
pendingThoughtSig = ""
|
|
return
|
|
}
|
|
part := map[string]interface{}{"thought": true}
|
|
part["text"] = text
|
|
if pendingThoughtSig != "" {
|
|
part["thoughtSignature"] = pendingThoughtSig
|
|
}
|
|
parts = append(parts, part)
|
|
}
|
|
pendingKind = ""
|
|
pendingText.Reset()
|
|
pendingThoughtSig = ""
|
|
}
|
|
|
|
normalizePart := func(partResult gjson.Result) map[string]interface{} {
|
|
var m map[string]interface{}
|
|
_ = json.Unmarshal([]byte(partResult.Raw), &m)
|
|
if m == nil {
|
|
m = map[string]interface{}{}
|
|
}
|
|
sig := partResult.Get("thoughtSignature").String()
|
|
if sig == "" {
|
|
sig = partResult.Get("thought_signature").String()
|
|
}
|
|
if sig != "" {
|
|
m["thoughtSignature"] = sig
|
|
delete(m, "thought_signature")
|
|
}
|
|
if inlineData, ok := m["inline_data"]; ok {
|
|
m["inlineData"] = inlineData
|
|
delete(m, "inline_data")
|
|
}
|
|
return m
|
|
}
|
|
|
|
for _, line := range bytes.Split(stream, []byte("\n")) {
|
|
trimmed := bytes.TrimSpace(line)
|
|
if len(trimmed) == 0 || !gjson.ValidBytes(trimmed) {
|
|
continue
|
|
}
|
|
|
|
root := gjson.ParseBytes(trimmed)
|
|
responseNode := root.Get("response")
|
|
if !responseNode.Exists() {
|
|
if root.Get("candidates").Exists() {
|
|
responseNode = root
|
|
} else {
|
|
continue
|
|
}
|
|
}
|
|
responseTemplate = responseNode.Raw
|
|
|
|
if traceResult := root.Get("traceId"); traceResult.Exists() && traceResult.String() != "" {
|
|
traceID = traceResult.String()
|
|
}
|
|
|
|
if roleResult := responseNode.Get("candidates.0.content.role"); roleResult.Exists() {
|
|
role = roleResult.String()
|
|
}
|
|
|
|
if finishResult := responseNode.Get("candidates.0.finishReason"); finishResult.Exists() && finishResult.String() != "" {
|
|
finishReason = finishResult.String()
|
|
}
|
|
|
|
if modelResult := responseNode.Get("modelVersion"); modelResult.Exists() && modelResult.String() != "" {
|
|
modelVersion = modelResult.String()
|
|
}
|
|
if responseIDResult := responseNode.Get("responseId"); responseIDResult.Exists() && responseIDResult.String() != "" {
|
|
responseID = responseIDResult.String()
|
|
}
|
|
if usageResult := responseNode.Get("usageMetadata"); usageResult.Exists() {
|
|
usageRaw = usageResult.Raw
|
|
} else if usageResult := root.Get("usageMetadata"); usageResult.Exists() {
|
|
usageRaw = usageResult.Raw
|
|
}
|
|
|
|
if partsResult := responseNode.Get("candidates.0.content.parts"); partsResult.IsArray() {
|
|
for _, part := range partsResult.Array() {
|
|
hasFunctionCall := part.Get("functionCall").Exists()
|
|
hasInlineData := part.Get("inlineData").Exists() || part.Get("inline_data").Exists()
|
|
sig := part.Get("thoughtSignature").String()
|
|
if sig == "" {
|
|
sig = part.Get("thought_signature").String()
|
|
}
|
|
text := part.Get("text").String()
|
|
thought := part.Get("thought").Bool()
|
|
|
|
if hasFunctionCall || hasInlineData {
|
|
flushPending()
|
|
parts = append(parts, normalizePart(part))
|
|
continue
|
|
}
|
|
|
|
if thought || part.Get("text").Exists() {
|
|
kind := "text"
|
|
if thought {
|
|
kind = "thought"
|
|
}
|
|
if pendingKind != "" && pendingKind != kind {
|
|
flushPending()
|
|
}
|
|
pendingKind = kind
|
|
pendingText.WriteString(text)
|
|
if kind == "thought" && sig != "" {
|
|
pendingThoughtSig = sig
|
|
}
|
|
continue
|
|
}
|
|
|
|
flushPending()
|
|
parts = append(parts, normalizePart(part))
|
|
}
|
|
}
|
|
}
|
|
flushPending()
|
|
|
|
if responseTemplate == "" {
|
|
responseTemplate = `{"candidates":[{"content":{"role":"model","parts":[]}}]}`
|
|
}
|
|
|
|
partsJSON, _ := json.Marshal(parts)
|
|
responseTemplate, _ = sjson.SetRaw(responseTemplate, "candidates.0.content.parts", string(partsJSON))
|
|
if role != "" {
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "candidates.0.content.role", role)
|
|
}
|
|
if finishReason != "" {
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "candidates.0.finishReason", finishReason)
|
|
}
|
|
if modelVersion != "" {
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "modelVersion", modelVersion)
|
|
}
|
|
if responseID != "" {
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "responseId", responseID)
|
|
}
|
|
if usageRaw != "" {
|
|
responseTemplate, _ = sjson.SetRaw(responseTemplate, "usageMetadata", usageRaw)
|
|
} else if !gjson.Get(responseTemplate, "usageMetadata").Exists() {
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "usageMetadata.promptTokenCount", 0)
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "usageMetadata.candidatesTokenCount", 0)
|
|
responseTemplate, _ = sjson.Set(responseTemplate, "usageMetadata.totalTokenCount", 0)
|
|
}
|
|
|
|
output := `{"response":{},"traceId":""}`
|
|
output, _ = sjson.SetRaw(output, "response", responseTemplate)
|
|
if traceID != "" {
|
|
output, _ = sjson.Set(output, "traceId", traceID)
|
|
}
|
|
return []byte(output)
|
|
}
|
|
|
|
// ExecuteStream performs a streaming request to the Antigravity API.
|
|
func (e *AntigravityExecutor) ExecuteStream(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (stream <-chan cliproxyexecutor.StreamChunk, err error) {
|
|
ctx = context.WithValue(ctx, "alt", "")
|
|
|
|
token, updatedAuth, errToken := e.ensureAccessToken(ctx, auth)
|
|
if errToken != nil {
|
|
return nil, errToken
|
|
}
|
|
if updatedAuth != nil {
|
|
auth = updatedAuth
|
|
}
|
|
|
|
reporter := newUsageReporter(ctx, e.Identifier(), req.Model, auth)
|
|
defer reporter.trackFailure(ctx, &err)
|
|
|
|
from := opts.SourceFormat
|
|
to := sdktranslator.FromString("antigravity")
|
|
translated := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), true)
|
|
|
|
translated = applyThinkingMetadataCLI(translated, req.Metadata, req.Model)
|
|
translated = util.ApplyGemini3ThinkingLevelFromMetadataCLI(req.Model, req.Metadata, translated)
|
|
translated = util.ApplyDefaultThinkingIfNeededCLI(req.Model, translated)
|
|
translated = normalizeAntigravityThinking(req.Model, translated)
|
|
translated = applyPayloadConfigWithRoot(e.cfg, req.Model, "antigravity", "request", translated)
|
|
|
|
baseURLs := antigravityBaseURLFallbackOrder(auth)
|
|
httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
|
|
// #region agent log
|
|
agentdebug.Log(
|
|
"H2",
|
|
"internal/runtime/executor/antigravity_executor.go:ExecuteStream:entry",
|
|
"stream_request_sizes",
|
|
map[string]any{
|
|
"model": req.Model,
|
|
"reqPayloadBytes": len(req.Payload),
|
|
"translatedBytes": len(translated),
|
|
"baseURLCount": len(baseURLs),
|
|
},
|
|
)
|
|
// #endregion agent log
|
|
|
|
var lastStatus int
|
|
var lastBody []byte
|
|
var lastErr error
|
|
|
|
for idx, baseURL := range baseURLs {
|
|
httpReq, errReq := e.buildRequest(ctx, auth, token, req.Model, translated, true, opts.Alt, baseURL)
|
|
if errReq != nil {
|
|
err = errReq
|
|
return nil, err
|
|
}
|
|
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errDo)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errDo
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
err = errDo
|
|
return nil, err
|
|
}
|
|
recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices {
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
if errRead != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errRead)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errRead
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
err = errRead
|
|
return nil, err
|
|
}
|
|
appendAPIResponseChunk(ctx, e.cfg, bodyBytes)
|
|
lastStatus = httpResp.StatusCode
|
|
lastBody = append([]byte(nil), bodyBytes...)
|
|
lastErr = nil
|
|
if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
retryAfter := antigravityRetryAfter(httpResp.StatusCode, httpResp.Header, bodyBytes)
|
|
err = statusErr{code: httpResp.StatusCode, msg: formatErrorMessage(bodyBytes, auth), retryAfter: retryAfter}
|
|
return nil, err
|
|
}
|
|
|
|
out := make(chan cliproxyexecutor.StreamChunk)
|
|
stream = out
|
|
go func(resp *http.Response) {
|
|
defer close(out)
|
|
defer func() {
|
|
if errClose := resp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
scanner := bufio.NewScanner(resp.Body)
|
|
scanner.Buffer(nil, streamScannerBuffer)
|
|
var param any
|
|
scanLines := 0
|
|
outChunks := 0
|
|
outBytes := 0
|
|
maxChunksPerLine := 0
|
|
maxPayloadBytes := 0
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
appendAPIResponseChunk(ctx, e.cfg, line)
|
|
scanLines++
|
|
|
|
// Filter usage metadata for all models
|
|
// Only retain usage statistics in the terminal chunk
|
|
line = FilterSSEUsageMetadata(line)
|
|
|
|
payload := jsonPayload(line)
|
|
if payload == nil {
|
|
continue
|
|
}
|
|
if n := len(payload); n > maxPayloadBytes {
|
|
maxPayloadBytes = n
|
|
}
|
|
|
|
if detail, ok := parseAntigravityStreamUsage(payload); ok {
|
|
reporter.publish(ctx, detail)
|
|
}
|
|
|
|
chunks := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, bytes.Clone(payload), ¶m)
|
|
if len(chunks) > maxChunksPerLine {
|
|
maxChunksPerLine = len(chunks)
|
|
}
|
|
for i := range chunks {
|
|
out <- cliproxyexecutor.StreamChunk{Payload: []byte(chunks[i])}
|
|
outChunks++
|
|
outBytes += len(chunks[i])
|
|
}
|
|
}
|
|
tail := sdktranslator.TranslateStream(ctx, to, from, req.Model, bytes.Clone(opts.OriginalRequest), translated, []byte("[DONE]"), ¶m)
|
|
for i := range tail {
|
|
out <- cliproxyexecutor.StreamChunk{Payload: []byte(tail[i])}
|
|
outChunks++
|
|
outBytes += len(tail[i])
|
|
}
|
|
if errScan := scanner.Err(); errScan != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errScan)
|
|
reporter.publishFailure(ctx)
|
|
// #region agent log
|
|
agentdebug.Log(
|
|
"H5",
|
|
"internal/runtime/executor/antigravity_executor.go:ExecuteStream:scanner_err",
|
|
"stream_scanner_error",
|
|
map[string]any{
|
|
"model": req.Model,
|
|
"scanLines": scanLines,
|
|
"error": errScan.Error(),
|
|
},
|
|
)
|
|
// #endregion agent log
|
|
out <- cliproxyexecutor.StreamChunk{Err: errScan}
|
|
} else {
|
|
reporter.ensurePublished(ctx)
|
|
}
|
|
// #region agent log
|
|
agentdebug.Log(
|
|
"H2",
|
|
"internal/runtime/executor/antigravity_executor.go:ExecuteStream:done",
|
|
"stream_totals",
|
|
map[string]any{
|
|
"model": req.Model,
|
|
"scanLines": scanLines,
|
|
"outChunks": outChunks,
|
|
"outBytes": outBytes,
|
|
"maxChunksPerLine": maxChunksPerLine,
|
|
"maxPayloadBytes": maxPayloadBytes,
|
|
},
|
|
)
|
|
// #endregion agent log
|
|
}(httpResp)
|
|
return stream, nil
|
|
}
|
|
|
|
switch {
|
|
case lastStatus != 0:
|
|
err = statusErr{code: lastStatus, msg: formatErrorMessage(lastBody, auth)}
|
|
case lastErr != nil:
|
|
err = lastErr
|
|
default:
|
|
err = statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// Refresh refreshes the authentication credentials using the refresh token.
|
|
func (e *AntigravityExecutor) Refresh(ctx context.Context, auth *cliproxyauth.Auth) (*cliproxyauth.Auth, error) {
|
|
if auth == nil {
|
|
return auth, nil
|
|
}
|
|
updated, errRefresh := e.refreshToken(ctx, auth.Clone())
|
|
if errRefresh != nil {
|
|
return nil, errRefresh
|
|
}
|
|
return updated, nil
|
|
}
|
|
|
|
// CountTokens counts tokens for the given request using the Antigravity API.
|
|
func (e *AntigravityExecutor) CountTokens(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (cliproxyexecutor.Response, error) {
|
|
token, updatedAuth, errToken := e.ensureAccessToken(ctx, auth)
|
|
if errToken != nil {
|
|
return cliproxyexecutor.Response{}, errToken
|
|
}
|
|
if updatedAuth != nil {
|
|
auth = updatedAuth
|
|
}
|
|
if strings.TrimSpace(token) == "" {
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
|
|
from := opts.SourceFormat
|
|
to := sdktranslator.FromString("antigravity")
|
|
respCtx := context.WithValue(ctx, "alt", opts.Alt)
|
|
|
|
baseURLs := antigravityBaseURLFallbackOrder(auth)
|
|
httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
|
|
var lastStatus int
|
|
var lastBody []byte
|
|
var lastErr error
|
|
|
|
for idx, baseURL := range baseURLs {
|
|
payload := sdktranslator.TranslateRequest(from, to, req.Model, bytes.Clone(req.Payload), false)
|
|
payload = applyThinkingMetadataCLI(payload, req.Metadata, req.Model)
|
|
payload = util.ApplyDefaultThinkingIfNeededCLI(req.Model, payload)
|
|
payload = normalizeAntigravityThinking(req.Model, payload)
|
|
payload = deleteJSONField(payload, "project")
|
|
payload = deleteJSONField(payload, "model")
|
|
payload = deleteJSONField(payload, "request.safetySettings")
|
|
|
|
base := strings.TrimSuffix(baseURL, "/")
|
|
if base == "" {
|
|
base = buildBaseURL(auth)
|
|
}
|
|
|
|
var requestURL strings.Builder
|
|
requestURL.WriteString(base)
|
|
requestURL.WriteString(antigravityCountTokensPath)
|
|
if opts.Alt != "" {
|
|
requestURL.WriteString("?$alt=")
|
|
requestURL.WriteString(url.QueryEscape(opts.Alt))
|
|
}
|
|
|
|
httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, requestURL.String(), bytes.NewReader(payload))
|
|
if errReq != nil {
|
|
return cliproxyexecutor.Response{}, errReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
httpReq.Header.Set("User-Agent", resolveUserAgent(auth))
|
|
httpReq.Header.Set("Accept", "application/json")
|
|
if host := resolveHost(base); host != "" {
|
|
httpReq.Host = host
|
|
}
|
|
|
|
recordAPIRequest(ctx, e.cfg, upstreamRequestLog{
|
|
URL: requestURL.String(),
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: payload,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errDo)
|
|
lastStatus = 0
|
|
lastBody = nil
|
|
lastErr = errDo
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
return cliproxyexecutor.Response{}, errDo
|
|
}
|
|
|
|
recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
if errRead != nil {
|
|
recordAPIResponseError(ctx, e.cfg, errRead)
|
|
return cliproxyexecutor.Response{}, errRead
|
|
}
|
|
appendAPIResponseChunk(ctx, e.cfg, bodyBytes)
|
|
|
|
if httpResp.StatusCode >= http.StatusOK && httpResp.StatusCode < http.StatusMultipleChoices {
|
|
count := gjson.GetBytes(bodyBytes, "totalTokens").Int()
|
|
translated := sdktranslator.TranslateTokenCount(respCtx, to, from, count, bodyBytes)
|
|
return cliproxyexecutor.Response{Payload: []byte(translated)}, nil
|
|
}
|
|
|
|
lastStatus = httpResp.StatusCode
|
|
lastBody = append([]byte(nil), bodyBytes...)
|
|
lastErr = nil
|
|
if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
retryAfter := antigravityRetryAfter(httpResp.StatusCode, httpResp.Header, bodyBytes)
|
|
return cliproxyexecutor.Response{}, statusErr{code: httpResp.StatusCode, msg: string(bodyBytes), retryAfter: retryAfter}
|
|
}
|
|
|
|
switch {
|
|
case lastStatus != 0:
|
|
return cliproxyexecutor.Response{}, statusErr{code: lastStatus, msg: string(lastBody)}
|
|
case lastErr != nil:
|
|
return cliproxyexecutor.Response{}, lastErr
|
|
default:
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusServiceUnavailable, msg: "antigravity executor: no base url available"}
|
|
}
|
|
}
|
|
|
|
// Embed performs an embedding request (not supported for Antigravity).
|
|
func (e *AntigravityExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) {
|
|
return cliproxyexecutor.Response{}, statusErr{code: http.StatusNotImplemented, msg: "embeddings not supported"}
|
|
}
|
|
|
|
// FetchAntigravityModels retrieves available models using the supplied auth.
|
|
func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *config.Config) []*registry.ModelInfo {
|
|
exec := &AntigravityExecutor{cfg: cfg}
|
|
token, updatedAuth, errToken := exec.ensureAccessToken(ctx, auth)
|
|
if errToken != nil || token == "" {
|
|
return nil
|
|
}
|
|
if updatedAuth != nil {
|
|
auth = updatedAuth
|
|
}
|
|
|
|
baseURLs := antigravityBaseURLFallbackOrder(auth)
|
|
httpClient := newProxyAwareHTTPClient(ctx, cfg, auth, 0)
|
|
|
|
for idx, baseURL := range baseURLs {
|
|
modelsURL := baseURL + antigravityModelsPath
|
|
httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, modelsURL, bytes.NewReader([]byte(`{}`)))
|
|
if errReq != nil {
|
|
return nil
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
httpReq.Header.Set("User-Agent", resolveUserAgent(auth))
|
|
if host := resolveHost(baseURL); host != "" {
|
|
httpReq.Host = host
|
|
}
|
|
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: models request error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
if errRead != nil {
|
|
if idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: models read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
return nil
|
|
}
|
|
if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices {
|
|
if httpResp.StatusCode == http.StatusTooManyRequests && idx+1 < len(baseURLs) {
|
|
log.Debugf("antigravity executor: models request rate limited on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1])
|
|
continue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
result := gjson.GetBytes(bodyBytes, "models")
|
|
if !result.Exists() {
|
|
return nil
|
|
}
|
|
|
|
now := time.Now().Unix()
|
|
modelConfig := registry.GetAntigravityModelConfig()
|
|
limits := antigravityBuildStaticLimitsIndex()
|
|
models := make([]*registry.ModelInfo, 0, len(result.Map()))
|
|
appendModel := func(id string) {
|
|
id = strings.TrimSpace(id)
|
|
if id == "" {
|
|
return
|
|
}
|
|
cfg := modelConfig[id]
|
|
modelName := id
|
|
if cfg != nil && cfg.Name != "" {
|
|
modelName = cfg.Name
|
|
}
|
|
modelInfo := ®istry.ModelInfo{
|
|
ID: id,
|
|
Name: modelName,
|
|
Description: id,
|
|
DisplayName: id,
|
|
Version: id,
|
|
Object: "model",
|
|
Created: now,
|
|
OwnedBy: antigravityAuthType,
|
|
Type: antigravityAuthType,
|
|
}
|
|
// Copy known limits from our static Gemini model list (best-effort).
|
|
// This improves /v1/models output (context_length/max_completion_tokens) for antigravity models.
|
|
if lim, ok := limits[id]; ok {
|
|
if modelInfo.InputTokenLimit == 0 && lim.InputTokenLimit > 0 {
|
|
modelInfo.InputTokenLimit = lim.InputTokenLimit
|
|
}
|
|
if modelInfo.OutputTokenLimit == 0 && lim.OutputTokenLimit > 0 {
|
|
modelInfo.OutputTokenLimit = lim.OutputTokenLimit
|
|
}
|
|
if modelInfo.ContextLength == 0 && lim.ContextLength > 0 {
|
|
modelInfo.ContextLength = lim.ContextLength
|
|
}
|
|
if modelInfo.MaxCompletionTokens == 0 && lim.MaxCompletionTokens > 0 {
|
|
modelInfo.MaxCompletionTokens = lim.MaxCompletionTokens
|
|
}
|
|
}
|
|
// Look up Thinking support from static config using ID
|
|
if cfg != nil {
|
|
if cfg.Thinking != nil {
|
|
modelInfo.Thinking = cfg.Thinking
|
|
}
|
|
if cfg.MaxCompletionTokens > 0 {
|
|
modelInfo.MaxCompletionTokens = cfg.MaxCompletionTokens
|
|
}
|
|
} else {
|
|
// Try lookup with aliased name for limits (e.g. gemini-3-pro-high -> gemini-3-pro-preview)
|
|
alias := alias2ModelName(id)
|
|
if lim, ok := limits[alias]; ok {
|
|
if modelInfo.InputTokenLimit == 0 && lim.InputTokenLimit > 0 {
|
|
modelInfo.InputTokenLimit = lim.InputTokenLimit
|
|
}
|
|
if modelInfo.OutputTokenLimit == 0 && lim.OutputTokenLimit > 0 {
|
|
modelInfo.OutputTokenLimit = lim.OutputTokenLimit
|
|
}
|
|
if modelInfo.ContextLength == 0 && lim.ContextLength > 0 {
|
|
modelInfo.ContextLength = lim.ContextLength
|
|
}
|
|
if modelInfo.MaxCompletionTokens == 0 && lim.MaxCompletionTokens > 0 {
|
|
modelInfo.MaxCompletionTokens = lim.MaxCompletionTokens
|
|
}
|
|
}
|
|
}
|
|
models = append(models, modelInfo)
|
|
}
|
|
for id := range result.Map() {
|
|
appendModel(id)
|
|
}
|
|
|
|
// Also append static models from config (e.g. antigravity-claude-*)
|
|
for id := range modelConfig {
|
|
if !strings.HasPrefix(id, "antigravity-") {
|
|
continue
|
|
}
|
|
appendModel(id)
|
|
}
|
|
|
|
return models
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type antigravityStaticLimit struct {
|
|
InputTokenLimit int
|
|
OutputTokenLimit int
|
|
ContextLength int
|
|
MaxCompletionTokens int
|
|
}
|
|
|
|
func antigravityBuildStaticLimitsIndex() map[string]antigravityStaticLimit {
|
|
index := make(map[string]antigravityStaticLimit)
|
|
add := func(models []*registry.ModelInfo) {
|
|
for _, m := range models {
|
|
if m == nil || strings.TrimSpace(m.ID) == "" {
|
|
continue
|
|
}
|
|
id := strings.TrimSpace(m.ID)
|
|
cur := index[id]
|
|
if cur.InputTokenLimit == 0 && m.InputTokenLimit > 0 {
|
|
cur.InputTokenLimit = m.InputTokenLimit
|
|
}
|
|
if cur.OutputTokenLimit == 0 && m.OutputTokenLimit > 0 {
|
|
cur.OutputTokenLimit = m.OutputTokenLimit
|
|
}
|
|
if cur.ContextLength == 0 && m.ContextLength > 0 {
|
|
cur.ContextLength = m.ContextLength
|
|
}
|
|
if cur.MaxCompletionTokens == 0 && m.MaxCompletionTokens > 0 {
|
|
cur.MaxCompletionTokens = m.MaxCompletionTokens
|
|
}
|
|
// Fallback: if only Gemini-style limits exist, treat them as context/output.
|
|
if cur.ContextLength == 0 && cur.InputTokenLimit > 0 {
|
|
cur.ContextLength = cur.InputTokenLimit
|
|
}
|
|
if cur.MaxCompletionTokens == 0 && cur.OutputTokenLimit > 0 {
|
|
cur.MaxCompletionTokens = cur.OutputTokenLimit
|
|
}
|
|
index[id] = cur
|
|
}
|
|
}
|
|
|
|
add(registry.GetGeminiModels())
|
|
add(registry.GetGeminiVertexModels())
|
|
add(registry.GetGeminiCLIModels())
|
|
add(registry.GetAIStudioModels())
|
|
add(registry.GetClaudeModels())
|
|
add(registry.GetQwenModels())
|
|
|
|
// Add explicit limits for antigravity-claude models.
|
|
// These models route to Claude via Antigravity but use aliases that don't match GetClaudeModels() IDs.
|
|
// Claude 3.5 Sonnet and Claude 3 Opus both have 200k context but we use a more conservative
|
|
// limit to account for prompt overhead and ensure successful API calls.
|
|
claudeAntigravityLimit := antigravityStaticLimit{
|
|
ContextLength: 180000, // Conservative (200k actual but leave room for overhead)
|
|
MaxCompletionTokens: 64000,
|
|
InputTokenLimit: 180000,
|
|
OutputTokenLimit: 64000,
|
|
}
|
|
index["antigravity-claude-sonnet-4-5"] = claudeAntigravityLimit
|
|
index["antigravity-claude-sonnet-4-5-thinking"] = claudeAntigravityLimit
|
|
index["antigravity-claude-opus-4-5-thinking"] = claudeAntigravityLimit
|
|
// Also add the underlying claude model IDs that alias2ModelName() converts to
|
|
index["claude-3-5-sonnet"] = claudeAntigravityLimit
|
|
index["claude-3-opus"] = claudeAntigravityLimit
|
|
// Add the user-facing model names (without prefix) that get passed to truncateConversation
|
|
index["claude-opus-4-5-thinking"] = claudeAntigravityLimit
|
|
index["claude-sonnet-4-5-thinking"] = claudeAntigravityLimit
|
|
index["claude-sonnet-4-5"] = claudeAntigravityLimit
|
|
|
|
return index
|
|
}
|
|
|
|
func (e *AntigravityExecutor) ensureAccessToken(ctx context.Context, auth *cliproxyauth.Auth) (string, *cliproxyauth.Auth, error) {
|
|
if auth == nil {
|
|
return "", nil, statusErr{code: http.StatusUnauthorized, msg: "missing auth"}
|
|
}
|
|
accessToken := metaStringValue(auth.Metadata, "access_token")
|
|
expiry := tokenExpiry(auth.Metadata)
|
|
if accessToken != "" && expiry.After(time.Now().Add(refreshSkew)) {
|
|
return accessToken, nil, nil
|
|
}
|
|
updated, errRefresh := e.refreshToken(ctx, auth.Clone())
|
|
if errRefresh != nil {
|
|
return "", nil, errRefresh
|
|
}
|
|
return metaStringValue(updated.Metadata, "access_token"), updated, nil
|
|
}
|
|
|
|
func (e *AntigravityExecutor) refreshToken(ctx context.Context, auth *cliproxyauth.Auth) (*cliproxyauth.Auth, error) {
|
|
if auth == nil {
|
|
return nil, statusErr{code: http.StatusUnauthorized, msg: "missing auth"}
|
|
}
|
|
refreshToken := metaStringValue(auth.Metadata, "refresh_token")
|
|
if refreshToken == "" {
|
|
return auth, statusErr{code: http.StatusUnauthorized, msg: "missing refresh token"}
|
|
}
|
|
|
|
form := url.Values{}
|
|
form.Set("client_id", antigravityClientID)
|
|
form.Set("client_secret", antigravityClientSecret)
|
|
form.Set("grant_type", "refresh_token")
|
|
form.Set("refresh_token", refreshToken)
|
|
|
|
httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, "https://oauth2.googleapis.com/token", strings.NewReader(form.Encode()))
|
|
if errReq != nil {
|
|
return auth, errReq
|
|
}
|
|
httpReq.Header.Set("Host", "oauth2.googleapis.com")
|
|
httpReq.Header.Set("User-Agent", defaultAntigravityAgent)
|
|
httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
|
|
httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
|
|
httpResp, errDo := httpClient.Do(httpReq)
|
|
if errDo != nil {
|
|
return auth, errDo
|
|
}
|
|
defer func() {
|
|
if errClose := httpResp.Body.Close(); errClose != nil {
|
|
log.Errorf("antigravity executor: close response body error: %v", errClose)
|
|
}
|
|
}()
|
|
|
|
bodyBytes, errRead := io.ReadAll(httpResp.Body)
|
|
if errRead != nil {
|
|
return auth, errRead
|
|
}
|
|
|
|
if httpResp.StatusCode < http.StatusOK || httpResp.StatusCode >= http.StatusMultipleChoices {
|
|
return auth, statusErr{code: httpResp.StatusCode, msg: string(bodyBytes)}
|
|
}
|
|
|
|
var tokenResp struct {
|
|
AccessToken string `json:"access_token"`
|
|
RefreshToken string `json:"refresh_token"`
|
|
ExpiresIn int64 `json:"expires_in"`
|
|
TokenType string `json:"token_type"`
|
|
}
|
|
if errUnmarshal := json.Unmarshal(bodyBytes, &tokenResp); errUnmarshal != nil {
|
|
return auth, errUnmarshal
|
|
}
|
|
|
|
if auth.Metadata == nil {
|
|
auth.Metadata = make(map[string]any)
|
|
}
|
|
auth.Metadata["access_token"] = tokenResp.AccessToken
|
|
if tokenResp.RefreshToken != "" {
|
|
auth.Metadata["refresh_token"] = tokenResp.RefreshToken
|
|
}
|
|
auth.Metadata["expires_in"] = tokenResp.ExpiresIn
|
|
auth.Metadata["timestamp"] = time.Now().UnixMilli()
|
|
auth.Metadata["expired"] = time.Now().Add(time.Duration(tokenResp.ExpiresIn) * time.Second).Format(time.RFC3339)
|
|
auth.Metadata["type"] = antigravityAuthType
|
|
return auth, nil
|
|
}
|
|
|
|
func (e *AntigravityExecutor) buildRequest(ctx context.Context, auth *cliproxyauth.Auth, token, modelName string, payload []byte, stream bool, alt, baseURL string) (*http.Request, error) {
|
|
if token == "" {
|
|
return nil, statusErr{code: http.StatusUnauthorized, msg: "missing access token"}
|
|
}
|
|
|
|
base := strings.TrimSuffix(baseURL, "/")
|
|
if base == "" {
|
|
base = buildBaseURL(auth)
|
|
}
|
|
path := antigravityGeneratePath
|
|
if stream {
|
|
path = antigravityStreamPath
|
|
}
|
|
var requestURL strings.Builder
|
|
requestURL.WriteString(base)
|
|
requestURL.WriteString(path)
|
|
if stream {
|
|
if alt != "" {
|
|
requestURL.WriteString("?$alt=")
|
|
requestURL.WriteString(url.QueryEscape(alt))
|
|
} else {
|
|
requestURL.WriteString("?alt=sse")
|
|
}
|
|
} else if alt != "" {
|
|
requestURL.WriteString("?$alt=")
|
|
requestURL.WriteString(url.QueryEscape(alt))
|
|
}
|
|
|
|
// Extract project_id from auth metadata if available
|
|
projectID := ""
|
|
if auth != nil && auth.Metadata != nil {
|
|
if pid, ok := auth.Metadata["project_id"].(string); ok {
|
|
projectID = strings.TrimSpace(pid)
|
|
}
|
|
}
|
|
payload = geminiToAntigravity(modelName, payload, projectID, stream)
|
|
payload, _ = sjson.SetBytes(payload, "model", alias2ModelName(modelName))
|
|
|
|
if strings.Contains(modelName, "claude") {
|
|
strJSON := string(payload)
|
|
paths := make([]string, 0)
|
|
util.Walk(gjson.ParseBytes(payload), "", "parametersJsonSchema", &paths)
|
|
for _, p := range paths {
|
|
strJSON, _ = util.RenameKey(strJSON, p, p[:len(p)-len("parametersJsonSchema")]+"parameters")
|
|
}
|
|
|
|
// Use the centralized schema cleaner to handle unsupported keywords,
|
|
// const->enum conversion, and flattening of types/anyOf.
|
|
strJSON = util.CleanJSONSchemaForAntigravity(strJSON)
|
|
|
|
// Normalize nullable types like ["string", "null"] -> "string"
|
|
// Vertex AI doesn't accept array-style nullable type definitions
|
|
strJSON = util.NormalizeNullableTypes(strJSON)
|
|
|
|
payload = []byte(strJSON)
|
|
}
|
|
|
|
httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, requestURL.String(), bytes.NewReader(payload))
|
|
if errReq != nil {
|
|
return nil, errReq
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/json")
|
|
httpReq.Header.Set("Authorization", "Bearer "+token)
|
|
httpReq.Header.Set("User-Agent", resolveUserAgent(auth))
|
|
if stream {
|
|
httpReq.Header.Set("Accept", "text/event-stream")
|
|
} else {
|
|
httpReq.Header.Set("Accept", "application/json")
|
|
}
|
|
if host := resolveHost(base); host != "" {
|
|
httpReq.Host = host
|
|
}
|
|
|
|
var authID, authLabel, authType, authValue string
|
|
if auth != nil {
|
|
authID = auth.ID
|
|
authLabel = auth.Label
|
|
authType, authValue = auth.AccountInfo()
|
|
}
|
|
recordAPIRequest(ctx, e.cfg, upstreamRequestLog{
|
|
URL: requestURL.String(),
|
|
Method: http.MethodPost,
|
|
Headers: httpReq.Header.Clone(),
|
|
Body: payload,
|
|
Provider: e.Identifier(),
|
|
AuthID: authID,
|
|
AuthLabel: authLabel,
|
|
AuthType: authType,
|
|
AuthValue: authValue,
|
|
})
|
|
|
|
return httpReq, nil
|
|
}
|
|
|
|
func tokenExpiry(metadata map[string]any) time.Time {
|
|
if metadata == nil {
|
|
return time.Time{}
|
|
}
|
|
if expStr, ok := metadata["expired"].(string); ok {
|
|
expStr = strings.TrimSpace(expStr)
|
|
if expStr != "" {
|
|
if parsed, errParse := time.Parse(time.RFC3339, expStr); errParse == nil {
|
|
return parsed
|
|
}
|
|
}
|
|
}
|
|
expiresIn, hasExpires := int64Value(metadata["expires_in"])
|
|
tsMs, hasTimestamp := int64Value(metadata["timestamp"])
|
|
if hasExpires && hasTimestamp {
|
|
return time.Unix(0, tsMs*int64(time.Millisecond)).Add(time.Duration(expiresIn) * time.Second)
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
// truncateConversation estimates token count and truncates history if it exceeds context limit.
|
|
// It also persists dropped messages to memory if a session ID is available.
|
|
func truncateConversation(payload []byte, modelID string, metadata map[string]any) []byte {
|
|
// 1. Get Context Length from static limits index (same as FetchAntigravityModels uses)
|
|
limit := 0
|
|
limits := antigravityBuildStaticLimitsIndex()
|
|
|
|
if lim, ok := limits[modelID]; ok {
|
|
if lim.ContextLength > 0 {
|
|
limit = lim.ContextLength
|
|
} else if lim.InputTokenLimit > 0 {
|
|
limit = lim.InputTokenLimit
|
|
}
|
|
}
|
|
|
|
if limit <= 0 {
|
|
// Try alias
|
|
alias := alias2ModelName(modelID)
|
|
if lim, ok := limits[alias]; ok {
|
|
if lim.ContextLength > 0 {
|
|
limit = lim.ContextLength
|
|
} else if lim.InputTokenLimit > 0 {
|
|
limit = lim.InputTokenLimit
|
|
}
|
|
}
|
|
}
|
|
|
|
// Default fallback if unknown (safe conservative)
|
|
if limit == 0 {
|
|
// If we still don't know the limit, we default to 128k tokens.
|
|
// This is a safe upper bound for most modern models (Claude 3.5, Gemini 1.5, GPT-4o).
|
|
// If the model is smaller (e.g. 8k, 32k), we might still overshoot, but this prevents
|
|
// sending multi-megabyte infinite prompts that are guaranteed to fail.
|
|
limit = 128000
|
|
log.Warnf("Unknown context limit for model %s; defaulting to %d tokens", modelID, limit)
|
|
}
|
|
|
|
// Apply a 0.7 safety factor to the limit to account for system overhead,
|
|
// tool definitions, and potential token counting differences.
|
|
// We use 0.7 (instead of 0.9) to be more aggressive with truncation.
|
|
limit = int(float64(limit) * 0.7)
|
|
|
|
// 2. Estimate Tokens (Rough char count)
|
|
// OpenAI generic rule of thumb: 1 token ~= 4 chars.
|
|
// Gemini/Antigravity can be different, but strict safety margin is better.
|
|
// Claude models tend to tokenize more aggressively, so use 3.0 chars/token for them.
|
|
fullJSON := string(payload)
|
|
charsPerToken := 3.5
|
|
if strings.Contains(strings.ToLower(modelID), "claude") {
|
|
charsPerToken = 3.0 // More conservative for Claude
|
|
}
|
|
estimatedTokens := int(float64(len(fullJSON)) / charsPerToken)
|
|
|
|
log.Infof("truncateConversation: model=%s, limit=%d, payloadLen=%d, estimatedTokens=%d", modelID, limit, len(fullJSON), estimatedTokens)
|
|
|
|
if estimatedTokens <= limit {
|
|
return payload
|
|
}
|
|
|
|
// 3. Truncate
|
|
// We need to parse "contents" and remove old messages.
|
|
// Typically, we keep system instruction (which is separate in Gemini)
|
|
// and the last few messages.
|
|
// Antigravity payload structure: { "request": { "contents": [ { "role": "...", "parts": [...] } ] } }
|
|
|
|
log.Infof("Truncating conversation for model %s: Est. %d tokens > Limit %d", modelID, estimatedTokens, limit)
|
|
|
|
contents := gjson.GetBytes(payload, "request.contents")
|
|
log.Infof("truncateConversation: request.contents exists=%v, isArray=%v", contents.Exists(), contents.IsArray())
|
|
if !contents.IsArray() {
|
|
// Fallback: check root level "contents" for other formats
|
|
contents = gjson.GetBytes(payload, "contents")
|
|
log.Infof("truncateConversation: fallback contents exists=%v, isArray=%v", contents.Exists(), contents.IsArray())
|
|
if !contents.IsArray() {
|
|
log.Warnf("truncateConversation: no contents array found, cannot truncate")
|
|
return payload
|
|
}
|
|
}
|
|
|
|
arr := contents.Array()
|
|
if len(arr) <= 2 {
|
|
// Too few messages to truncate meaningful history without breaking context
|
|
return payload
|
|
}
|
|
|
|
// Strategy: Keep last N messages that fit.
|
|
// We iterate backwards, summing estimated tokens until we hit ~Limit * 0.9 (safety buffer).
|
|
|
|
keepIdx := 0
|
|
currentChars := 0
|
|
// Base overhead
|
|
currentChars += len(fullJSON) - len(contents.Raw)
|
|
|
|
// Always keep the last message (User prompt)
|
|
lastMsg := arr[len(arr)-1]
|
|
currentChars += len(lastMsg.Raw)
|
|
|
|
// Iterate backwards from second to last
|
|
for i := len(arr) - 2; i >= 0; i-- {
|
|
msg := arr[i]
|
|
msgLen := len(msg.Raw)
|
|
|
|
// If adding this message exceeds limit, stop here
|
|
// (We use a slightly tighter limit for safety)
|
|
newTotal := currentChars + msgLen
|
|
newEstTokens := int(float64(newTotal) / 3.5)
|
|
|
|
if newEstTokens > limit {
|
|
// Stop, this message and all before it (up to 0) must go.
|
|
// But wait, if this is a tool_response, we MUST keep its corresponding tool_call.
|
|
// And if it's a tool_call, we generally want to keep it if we keep the response.
|
|
// For simplicity in this rough pass: Just cut.
|
|
// Improving: Ensure we don't split tool pairs?
|
|
// Gemini is strict about function_call <-> function_response ordering.
|
|
// If we cut a function_call, we must cut its response (which is later, so we would have processed it).
|
|
// If we cut a function_response, we must cut the call (which is earlier).
|
|
|
|
// Actually, if we are iterating backwards:
|
|
// "User" -> "Model" -> "Tool" -> "Model"
|
|
// If we decide to keep "Tool", we must keep "Model" (call).
|
|
|
|
// Simple heuristics:
|
|
// If we drop a message at index i, we assume everything < i is also dropped.
|
|
// We just need to find the split point.
|
|
keepIdx = i + 1
|
|
break
|
|
}
|
|
currentChars += msgLen
|
|
}
|
|
|
|
// Perform the cut and persist dropped memory
|
|
if keepIdx > 0 {
|
|
// Collect dropped messages for memory
|
|
droppedEvents := make([]memory.Event, 0, keepIdx)
|
|
for i := 0; i < keepIdx; i++ {
|
|
msg := arr[i]
|
|
role := msg.Get("role").String()
|
|
// Extract text content (skip thinking parts to avoid leaking internal reasoning)
|
|
var textBuilder strings.Builder
|
|
parts := msg.Get("parts")
|
|
if parts.IsArray() {
|
|
for _, p := range parts.Array() {
|
|
// Skip thinking/thought parts - these are internal reasoning
|
|
// and should not be captured into memory/summary
|
|
if p.Get("thought").Bool() {
|
|
continue
|
|
}
|
|
if t := p.Get("text").String(); t != "" {
|
|
textBuilder.WriteString(t)
|
|
textBuilder.WriteString("\n")
|
|
}
|
|
}
|
|
}
|
|
text := strings.TrimSpace(textBuilder.String())
|
|
if text != "" {
|
|
droppedEvents = append(droppedEvents, memory.Event{
|
|
TS: time.Now(),
|
|
Kind: "message",
|
|
Role: role,
|
|
Type: "text", // simplify for now
|
|
Text: text,
|
|
})
|
|
}
|
|
}
|
|
|
|
if len(droppedEvents) > 0 {
|
|
sessionID := extractSessionID(metadata)
|
|
if sessionID != "" {
|
|
if store := getMemoryStore(); store != nil {
|
|
log.Debugf("Persisting %d dropped messages to memory for session %s", len(droppedEvents), sessionID)
|
|
if err := store.Append(sessionID, droppedEvents); err != nil {
|
|
log.Warnf("Failed to append dropped messages to memory: %v", err)
|
|
}
|
|
|
|
// Build anchored summary (Factory-style structured summarization)
|
|
if fs, ok := store.(*memory.FileStore); ok {
|
|
latestIntent := extractLatestUserIntent(droppedEvents)
|
|
if err := fs.UpsertAnchoredSummary(sessionID, droppedEvents, "", latestIntent); err != nil {
|
|
log.Warnf("Failed to upsert anchored summary: %v", err)
|
|
} else {
|
|
log.Infof("Updated anchored summary for session %s with %d dropped messages", sessionID, len(droppedEvents))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Construct new contents array
|
|
// We have to be careful with sjson/gjson on large arrays.
|
|
// Rebuilding the array is safer.
|
|
var newContents []string
|
|
for i := keepIdx; i < len(arr); i++ {
|
|
newContents = append(newContents, arr[i].Raw)
|
|
}
|
|
// Join them
|
|
newJsonStr := "[" + strings.Join(newContents, ",") + "]"
|
|
|
|
// Set the truncated contents back - try request.contents first (Antigravity format)
|
|
updated, err := sjson.SetRawBytes(payload, "request.contents", []byte(newJsonStr))
|
|
if err != nil {
|
|
// Fallback to root contents
|
|
updated, err = sjson.SetRawBytes(payload, "contents", []byte(newJsonStr))
|
|
if err != nil {
|
|
log.Errorf("Failed to truncate payload: %v", err)
|
|
return payload
|
|
}
|
|
}
|
|
return updated
|
|
}
|
|
|
|
return payload
|
|
}
|
|
|
|
func getMemoryStore() memory.Store {
|
|
// Replicates logic from codex_prompt_budget.go to locate memory dir
|
|
base := strings.TrimSpace(os.Getenv("CLIPROXY_MEMORY_DIR"))
|
|
if base == "" {
|
|
if w := util.WritablePath(); w != "" {
|
|
base = filepath.Join(w, ".proxypilot", "memory")
|
|
} else {
|
|
base = filepath.Join(".proxypilot", "memory")
|
|
}
|
|
}
|
|
return memory.NewFileStore(base)
|
|
}
|
|
|
|
// injectAnchoredSummary prepends the anchored summary to the system instruction.
|
|
// This allows the agent to recall context from truncated conversation history.
|
|
func injectAnchoredSummary(payload []byte, modelID string, metadata map[string]any) []byte {
|
|
sessionID := extractSessionID(metadata)
|
|
if sessionID == "" {
|
|
return payload
|
|
}
|
|
|
|
store := getMemoryStore()
|
|
if store == nil {
|
|
return payload
|
|
}
|
|
|
|
fs, ok := store.(*memory.FileStore)
|
|
if !ok {
|
|
return payload
|
|
}
|
|
|
|
// Read the anchored summary (max 8k chars to avoid bloating)
|
|
summary := fs.ReadSummary(sessionID, 8000)
|
|
if strings.TrimSpace(summary) == "" {
|
|
return payload
|
|
}
|
|
|
|
log.Debugf("Injecting anchored summary (%d chars) for session %s", len(summary), sessionID)
|
|
|
|
// Get current system instruction
|
|
sysInstr := gjson.GetBytes(payload, "request.systemInstruction.parts.0.text").String()
|
|
|
|
// Check if summary is already present (avoid duplicates)
|
|
if strings.Contains(sysInstr, "## Session Context (from previous turns)") {
|
|
return payload
|
|
}
|
|
|
|
// Prepend the summary with a clear header
|
|
contextPrefix := "## Session Context (from previous turns)\n\n" +
|
|
"The following summarizes earlier conversation that was truncated due to context limits:\n\n" +
|
|
summary + "\n\n---\n\n"
|
|
|
|
newInstr := contextPrefix + sysInstr
|
|
|
|
// Update the system instruction
|
|
updated, err := sjson.SetBytes(payload, "request.systemInstruction.parts.0.text", newInstr)
|
|
if err != nil {
|
|
log.Warnf("Failed to inject anchored summary: %v", err)
|
|
return payload
|
|
}
|
|
|
|
return updated
|
|
}
|
|
|
|
func extractSessionID(metadata map[string]any) string {
|
|
if metadata == nil {
|
|
log.Debugf("extractSessionID: metadata is nil")
|
|
return ""
|
|
}
|
|
// Try standard headers often mapped to metadata
|
|
if v, ok := metadata["X-CLIProxyAPI-Session"].(string); ok && v != "" {
|
|
log.Debugf("extractSessionID: found X-CLIProxyAPI-Session=%s", v)
|
|
return v
|
|
}
|
|
if v, ok := metadata["X-Session-Id"].(string); ok && v != "" {
|
|
log.Debugf("extractSessionID: found X-Session-Id=%s", v)
|
|
return v
|
|
}
|
|
if v, ok := metadata["session_id"].(string); ok && v != "" {
|
|
log.Debugf("extractSessionID: found session_id=%s", v)
|
|
return v
|
|
}
|
|
// Log what keys ARE present for debugging
|
|
keys := make([]string, 0, len(metadata))
|
|
for k := range metadata {
|
|
keys = append(keys, k)
|
|
}
|
|
log.Debugf("extractSessionID: no session found in metadata, keys present: %v", keys)
|
|
return ""
|
|
}
|
|
|
|
// extractLatestUserIntent finds the last user message from dropped events to use as intent.
|
|
func extractLatestUserIntent(events []memory.Event) string {
|
|
for i := len(events) - 1; i >= 0; i-- {
|
|
if strings.EqualFold(events[i].Role, "user") && events[i].Text != "" {
|
|
intent := events[i].Text
|
|
// Limit length to avoid huge intents
|
|
if len(intent) > 1500 {
|
|
intent = intent[:1500] + "...[truncated]..."
|
|
}
|
|
return intent
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func metaStringValue(metadata map[string]any, key string) string {
|
|
if metadata == nil {
|
|
return ""
|
|
}
|
|
if v, ok := metadata[key]; ok {
|
|
switch typed := v.(type) {
|
|
case string:
|
|
return strings.TrimSpace(typed)
|
|
case []byte:
|
|
return strings.TrimSpace(string(typed))
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func int64Value(value any) (int64, bool) {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
return int64(typed), true
|
|
case int64:
|
|
return typed, true
|
|
case float64:
|
|
return int64(typed), true
|
|
case json.Number:
|
|
if i, errParse := typed.Int64(); errParse == nil {
|
|
return i, true
|
|
}
|
|
case string:
|
|
if strings.TrimSpace(typed) == "" {
|
|
return 0, false
|
|
}
|
|
if i, errParse := strconv.ParseInt(strings.TrimSpace(typed), 10, 64); errParse == nil {
|
|
return i, true
|
|
}
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func buildBaseURL(auth *cliproxyauth.Auth) string {
|
|
if baseURLs := antigravityBaseURLFallbackOrder(auth); len(baseURLs) > 0 {
|
|
return baseURLs[0]
|
|
}
|
|
return antigravityBaseURLDaily
|
|
}
|
|
|
|
func resolveHost(base string) string {
|
|
parsed, errParse := url.Parse(base)
|
|
if errParse != nil {
|
|
return ""
|
|
}
|
|
if parsed.Host != "" {
|
|
return parsed.Host
|
|
}
|
|
return strings.TrimPrefix(strings.TrimPrefix(base, "https://"), "http://")
|
|
}
|
|
|
|
func resolveUserAgent(auth *cliproxyauth.Auth) string {
|
|
if auth != nil {
|
|
if auth.Attributes != nil {
|
|
if ua := strings.TrimSpace(auth.Attributes["user_agent"]); ua != "" {
|
|
return ua
|
|
}
|
|
}
|
|
if auth.Metadata != nil {
|
|
if ua, ok := auth.Metadata["user_agent"].(string); ok && strings.TrimSpace(ua) != "" {
|
|
return strings.TrimSpace(ua)
|
|
}
|
|
}
|
|
}
|
|
return defaultAntigravityAgent
|
|
}
|
|
|
|
func antigravityBaseURLFallbackOrder(auth *cliproxyauth.Auth) []string {
|
|
if base := resolveCustomAntigravityBaseURL(auth); base != "" {
|
|
return []string{base}
|
|
}
|
|
return []string{
|
|
antigravityBaseURLDaily,
|
|
antigravitySandboxBaseURLDaily,
|
|
antigravityBaseURLProd,
|
|
}
|
|
}
|
|
|
|
func antigravityRetryAfter(statusCode int, headers http.Header, body []byte) *time.Duration {
|
|
if statusCode != http.StatusTooManyRequests {
|
|
return nil
|
|
}
|
|
if headers != nil {
|
|
if val := headers.Get("Retry-After"); val != "" {
|
|
if seconds, err := strconv.Atoi(val); err == nil && seconds > 0 {
|
|
d := time.Duration(seconds) * time.Second
|
|
return &d
|
|
}
|
|
if t, err := time.Parse(time.RFC1123, val); err == nil {
|
|
d := time.Until(t)
|
|
if d > 0 {
|
|
return &d
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(body) == 0 {
|
|
return nil
|
|
}
|
|
if retryAfter, err := parseRetryDelay(body); err == nil && retryAfter != nil {
|
|
return retryAfter
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func resolveCustomAntigravityBaseURL(auth *cliproxyauth.Auth) string {
|
|
if auth == nil {
|
|
return ""
|
|
}
|
|
if auth.Attributes != nil {
|
|
if v := strings.TrimSpace(auth.Attributes["base_url"]); v != "" {
|
|
return strings.TrimSuffix(v, "/")
|
|
}
|
|
}
|
|
if auth.Metadata != nil {
|
|
if v, ok := auth.Metadata["base_url"].(string); ok {
|
|
v = strings.TrimSpace(v)
|
|
if v != "" {
|
|
return strings.TrimSuffix(v, "/")
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func geminiToAntigravity(modelName string, payload []byte, projectID string, stream bool) []byte {
|
|
template, _ := sjson.Set(string(payload), "model", modelName)
|
|
template, _ = sjson.Set(template, "userAgent", "antigravity")
|
|
|
|
// Use real project ID from auth if available, otherwise generate random (legacy fallback)
|
|
if projectID != "" {
|
|
template, _ = sjson.Set(template, "project", projectID)
|
|
} else {
|
|
template, _ = sjson.Set(template, "project", generateProjectID())
|
|
}
|
|
template, _ = sjson.Set(template, "requestId", generateRequestID())
|
|
template, _ = sjson.Set(template, "request.sessionId", generateStableSessionID(payload))
|
|
|
|
template, _ = sjson.Delete(template, "request.safetySettings")
|
|
template, _ = sjson.Set(template, "request.toolConfig.functionCallingConfig.mode", "VALIDATED")
|
|
|
|
if !strings.HasPrefix(modelName, "gemini-3-") {
|
|
if thinkingLevel := gjson.Get(template, "request.generationConfig.thinkingConfig.thinkingLevel"); thinkingLevel.Exists() {
|
|
template, _ = sjson.Delete(template, "request.generationConfig.thinkingConfig.thinkingLevel")
|
|
template, _ = sjson.Set(template, "request.generationConfig.thinkingConfig.thinkingBudget", -1)
|
|
}
|
|
}
|
|
|
|
if strings.Contains(modelName, "claude") {
|
|
gjson.Get(template, "request.tools").ForEach(func(key, tool gjson.Result) bool {
|
|
tool.Get("functionDeclarations").ForEach(func(funKey, funcDecl gjson.Result) bool {
|
|
if funcDecl.Get("parametersJsonSchema").Exists() {
|
|
template, _ = sjson.SetRaw(template, fmt.Sprintf("request.tools.%d.functionDeclarations.%d.parameters", key.Int(), funKey.Int()), funcDecl.Get("parametersJsonSchema").Raw)
|
|
template, _ = sjson.Delete(template, fmt.Sprintf("request.tools.%d.functionDeclarations.%d.parameters.$schema", key.Int(), funKey.Int()))
|
|
template, _ = sjson.Delete(template, fmt.Sprintf("request.tools.%d.functionDeclarations.%d.parametersJsonSchema", key.Int(), funKey.Int()))
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
})
|
|
} else {
|
|
template, _ = sjson.Delete(template, "request.generationConfig.maxOutputTokens")
|
|
}
|
|
|
|
return []byte(template)
|
|
}
|
|
|
|
func generateRequestID() string {
|
|
return "agent-" + uuid.NewString()
|
|
}
|
|
|
|
func generateSessionID() string {
|
|
randSourceMutex.Lock()
|
|
n := randSource.Int63n(9_000_000_000_000_000_000)
|
|
randSourceMutex.Unlock()
|
|
return "-" + strconv.FormatInt(n, 10)
|
|
}
|
|
|
|
func generateStableSessionID(payload []byte) string {
|
|
contents := gjson.GetBytes(payload, "request.contents")
|
|
if contents.IsArray() {
|
|
for _, content := range contents.Array() {
|
|
if content.Get("role").String() == "user" {
|
|
text := content.Get("parts.0.text").String()
|
|
if text != "" {
|
|
h := sha256.Sum256([]byte(text))
|
|
n := int64(binary.BigEndian.Uint64(h[:8])) & 0x7FFFFFFFFFFFFFFF
|
|
return "-" + strconv.FormatInt(n, 10)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return generateSessionID()
|
|
}
|
|
|
|
func generateProjectID() string {
|
|
adjectives := []string{"useful", "bright", "swift", "calm", "bold"}
|
|
nouns := []string{"fuze", "wave", "spark", "flow", "core"}
|
|
randSourceMutex.Lock()
|
|
adj := adjectives[randSource.Intn(len(adjectives))]
|
|
noun := nouns[randSource.Intn(len(nouns))]
|
|
randSourceMutex.Unlock()
|
|
randomPart := strings.ToLower(uuid.NewString())[:5]
|
|
return adj + "-" + noun + "-" + randomPart
|
|
}
|
|
|
|
func modelName2Alias(modelName string) string {
|
|
switch modelName {
|
|
case "rev19-uic3-1p":
|
|
return "gemini-2.5-computer-use-preview-10-2025"
|
|
case "rev19-uic3-img-1p":
|
|
return "gemini-2.5-image-pro-preview"
|
|
case "rev19-f1-1p":
|
|
return "gemini-2.5-flash"
|
|
case "rev19-f1-lite-1p":
|
|
return "gemini-2.5-flash-lite"
|
|
case "gemini-3-flash", "gemini-3-flash-high":
|
|
return "gemini-3-flash-preview"
|
|
case "gemini-3-pro-image":
|
|
return "gemini-3-pro-image-preview"
|
|
case "gemini-3-pro-high":
|
|
return "gemini-3-pro-preview"
|
|
case "gemini-3-pro-low":
|
|
return "gemini-3-pro-low-preview"
|
|
case "claude-sonnet-4-5":
|
|
return "antigravity-claude-sonnet-4-5"
|
|
case "claude-sonnet-4-5-thinking":
|
|
return "antigravity-claude-sonnet-4-5-thinking"
|
|
case "claude-opus-4-5-thinking":
|
|
return "antigravity-claude-opus-4-5-thinking"
|
|
case "chat_20706", "chat_23310", "gemini-2.5-flash-thinking", "gemini-2.5-pro":
|
|
return ""
|
|
default:
|
|
return modelName
|
|
}
|
|
}
|
|
|
|
func alias2ModelName(modelName string) string {
|
|
switch modelName {
|
|
case "gemini-2.5-computer-use-preview-10-2025":
|
|
return "rev19-uic3-1p"
|
|
case "gemini-2.5-image-pro-preview":
|
|
return "rev19-uic3-img-1p"
|
|
case "gemini-2.5-flash":
|
|
return "rev19-f1-1p"
|
|
case "gemini-2.5-flash-lite":
|
|
return "rev19-f1-lite-1p"
|
|
case "gemini-3-flash-preview":
|
|
return "gemini-3-flash"
|
|
case "gemini-3-pro-image-preview":
|
|
return "gemini-3-pro-image"
|
|
case "gemini-3-pro-preview":
|
|
return "gemini-3-pro-high"
|
|
case "gemini-3-pro-low-preview":
|
|
return "gemini-3-pro-low"
|
|
case "gemini-claude-sonnet-4-5":
|
|
return "claude-sonnet-4-5"
|
|
case "gemini-claude-sonnet-4-5-thinking":
|
|
return "claude-sonnet-4-5-thinking"
|
|
case "gemini-claude-opus-4-5-thinking":
|
|
return "claude-opus-4-5-thinking"
|
|
default:
|
|
return modelName
|
|
}
|
|
}
|
|
|
|
// normalizeAntigravityThinking clamps or removes thinking config based on model support.
|
|
// For Claude models, it additionally ensures thinking budget < max_tokens.
|
|
func normalizeAntigravityThinking(model string, payload []byte) []byte {
|
|
payload = util.StripThinkingConfigIfUnsupported(model, payload)
|
|
if !util.ModelSupportsThinking(model) {
|
|
return payload
|
|
}
|
|
budget := gjson.GetBytes(payload, "request.generationConfig.thinkingConfig.thinkingBudget")
|
|
if !budget.Exists() {
|
|
return payload
|
|
}
|
|
raw := int(budget.Int())
|
|
normalized := util.NormalizeThinkingBudget(model, raw)
|
|
|
|
isClaude := strings.Contains(strings.ToLower(model), "claude")
|
|
if isClaude {
|
|
effectiveMax, setDefaultMax := antigravityEffectiveMaxTokens(model, payload)
|
|
if effectiveMax > 0 && normalized >= effectiveMax {
|
|
normalized = effectiveMax - 1
|
|
}
|
|
minBudget := antigravityMinThinkingBudget(model)
|
|
if minBudget > 0 && normalized >= 0 && normalized < minBudget {
|
|
// Budget is below minimum, remove thinking config entirely
|
|
payload, _ = sjson.DeleteBytes(payload, "request.generationConfig.thinkingConfig")
|
|
return payload
|
|
}
|
|
if setDefaultMax {
|
|
if res, errSet := sjson.SetBytes(payload, "request.generationConfig.maxOutputTokens", effectiveMax); errSet == nil {
|
|
payload = res
|
|
}
|
|
}
|
|
}
|
|
|
|
updated, err := sjson.SetBytes(payload, "request.generationConfig.thinkingConfig.thinkingBudget", normalized)
|
|
if err != nil {
|
|
return payload
|
|
}
|
|
return updated
|
|
}
|
|
|
|
// antigravityEffectiveMaxTokens returns the max tokens to cap thinking:
|
|
// prefer request-provided maxOutputTokens; otherwise fall back to model default.
|
|
// The boolean indicates whether the value came from the model default (and thus should be written back).
|
|
func antigravityEffectiveMaxTokens(model string, payload []byte) (max int, fromModel bool) {
|
|
if maxTok := gjson.GetBytes(payload, "request.generationConfig.maxOutputTokens"); maxTok.Exists() && maxTok.Int() > 0 {
|
|
return int(maxTok.Int()), false
|
|
}
|
|
if modelInfo := registry.GetGlobalRegistry().GetModelInfo(model); modelInfo != nil && modelInfo.MaxCompletionTokens > 0 {
|
|
return modelInfo.MaxCompletionTokens, true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
// antigravityMinThinkingBudget returns the minimum thinking budget for a model.
|
|
// Falls back to -1 if no model info is found.
|
|
func antigravityMinThinkingBudget(model string) int {
|
|
if modelInfo := registry.GetGlobalRegistry().GetModelInfo(model); modelInfo != nil && modelInfo.Thinking != nil {
|
|
return modelInfo.Thinking.Min
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func formatErrorMessage(body []byte, auth *cliproxyauth.Auth) string {
|
|
msg := strings.TrimSpace(string(body))
|
|
if val := gjson.GetBytes(body, "error.message"); val.Exists() {
|
|
msg = val.String()
|
|
} else if val := gjson.GetBytes(body, "message"); val.Exists() {
|
|
msg = val.String()
|
|
}
|
|
|
|
if _, acc := auth.AccountInfo(); acc != "" {
|
|
msg += " (Account: " + acc + ")"
|
|
}
|
|
return "API Error: " + msg
|
|
}
|