Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
19 kB · 542 lines
Go
at commit 291cfb87
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543package executor
import ( "bytes" "context" "crypto/sha256" "encoding/binary" "fmt" "io" "net/http" "net/url" "strconv" "strings" "time"
"github.com/google/uuid" "github.com/router-for-me/CLIProxyAPI/v7/internal/misc" "github.com/router-for-me/CLIProxyAPI/v7/internal/registry" "github.com/router-for-me/CLIProxyAPI/v7/internal/runtime/executor/helps" "github.com/router-for-me/CLIProxyAPI/v7/internal/util" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth" log "github.com/sirupsen/logrus" "github.com/tidwall/gjson" "github.com/tidwall/sjson")
func (e *AntigravityExecutor) buildRequest(ctx context.Context, auth *cliproxyauth.Auth, token, modelName string, payload []byte, stream bool, alt, baseURL string, derivedSessionIDs ...string) (*http.Request, error) { if token == "" { return nil, statusErr{code: http.StatusUnauthorized, msg: "missing access token"} }
base := strings.TrimSuffix(baseURL, "/") if base == "" { base = resolveAntigravityRequestBaseURL(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)) }
projectID, errProject := e.projectIDForRequest(ctx, auth, token) if errProject != nil { return nil, errProject } payload = geminiToAntigravity(modelName, payload, projectID, derivedSessionIDs...)
// Cap maxOutputTokens to model's max_completion_tokens from registry if maxOut := gjson.GetBytes(payload, "request.generationConfig.maxOutputTokens"); maxOut.Exists() && maxOut.Type == gjson.Number { if modelInfo := registry.LookupModelInfo(modelName, "antigravity"); modelInfo != nil && modelInfo.MaxCompletionTokens > 0 { if int(maxOut.Int()) > modelInfo.MaxCompletionTokens { payload, _ = sjson.SetBytes(payload, "request.generationConfig.maxOutputTokens", modelInfo.MaxCompletionTokens) } } }
useAntigravitySchema := strings.Contains(modelName, "claude") || strings.Contains(modelName, "gemini-3-pro") || strings.Contains(modelName, "gemini-3.1-pro") var ( bodyReader io.Reader payloadLog []byte ) if antigravityRequestNeedsSchemaSanitization(payload) { payloadStr := sanitizeAntigravityRequestSchemas(string(payload), useAntigravitySchema)
if strings.Contains(modelName, "claude") { updated, _ := sjson.SetBytes([]byte(payloadStr), "request.toolConfig.functionCallingConfig.mode", "VALIDATED") payloadStr = string(updated) } else { payloadStr, _ = sjson.Delete(payloadStr, "request.generationConfig.maxOutputTokens") }
payloadStrBytes := applyAntigravityNativeSignatureReplayIfNeeded(modelName, []byte(payloadStr)) bodyReader = bytes.NewReader(payloadStrBytes) if e.cfg != nil && e.cfg.RequestLog { payloadLog = append([]byte(nil), payloadStrBytes...) } } else { if strings.Contains(modelName, "claude") { payload, _ = sjson.SetBytes(payload, "request.toolConfig.functionCallingConfig.mode", "VALIDATED") } else { payload, _ = sjson.DeleteBytes(payload, "request.generationConfig.maxOutputTokens") }
payload = applyAntigravityNativeSignatureReplayIfNeeded(modelName, payload) bodyReader = bytes.NewReader(payload) if e.cfg != nil && e.cfg.RequestLog { payloadLog = append([]byte(nil), payload...) } }
// if useAntigravitySchema { // systemInstructionPartsResult := gjson.Get(payloadStr, "request.systemInstruction.parts") // payloadStr, _ = sjson.SetBytes([]byte(payloadStr), "request.systemInstruction.role", "user") // payloadStr, _ = sjson.SetBytes([]byte(payloadStr), "request.systemInstruction.parts.0.text", systemInstruction) // payloadStr, _ = sjson.SetBytes([]byte(payloadStr), "request.systemInstruction.parts.1.text", fmt.Sprintf("Please ignore following [ignore]%s[/ignore]", systemInstruction))
// if systemInstructionPartsResult.Exists() && systemInstructionPartsResult.IsArray() { // for _, partResult := range systemInstructionPartsResult.Array() { // payloadStr, _ = sjson.SetRawBytes([]byte(payloadStr), "request.systemInstruction.parts.-1", []byte(partResult.Raw)) // } // } // }
httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, requestURL.String(), bodyReader) if errReq != nil { return nil, errReq } // Deliberately no httpReq.Close: the native Antigravity client omits the // Connection header and keeps its HTTP/1.1 connections alive, so forcing // "Connection: close" would both deviate from that fingerprint and defeat the // shared connection pool by discarding every established TCP + TLS session. httpReq.Header.Set("Content-Type", "application/json") httpReq.Header.Set("Authorization", "Bearer "+token) httpReq.Header.Set("User-Agent", resolveUserAgent(auth)) if host := resolveHost(base); host != "" { httpReq.Host = host } var attrs map[string]string if auth != nil { attrs = auth.Attributes } util.ApplyCustomHeadersFromAttrs(httpReq, attrs)
var authID, authLabel, authType, authValue string if auth != nil { authID = auth.ID authLabel = auth.Label authType, authValue = auth.AccountInfo() } helps.RecordAPIRequest(ctx, e.cfg, helps.UpstreamRequestLog{ URL: requestURL.String(), Method: http.MethodPost, Headers: httpReq.Header.Clone(), Body: payloadLog, Provider: e.Identifier(), AuthID: authID, AuthLabel: authLabel, AuthType: authType, AuthValue: authValue, })
return httpReq, nil}
// sanitizeAntigravityRequestSchemas cleans the JSON schemas carried by an Antigravity request.//// Cleaning is applied only to the payload locations that actually hold a JSON schema. The schema// cleaner rewrites keys such as "title", "format", "default" and "const", which are also ordinary// data keys inside functionCall arguments replayed from conversation history. Running it over the// whole document silently mutated that history, so tools lost required argument fields and the// model imitated the corrupted examples on later turns.func sanitizeAntigravityRequestSchemas(payloadStr string, useAntigravitySchema bool) string { payloadStr = sanitizeAntigravityToolSchemas(payloadStr, useAntigravitySchema) return sanitizeAntigravityGenerationSchemas(payloadStr)}
// sanitizeAntigravityToolSchemas applies the existing declaration rewrites to// a small document containing only request.tools, then replaces that subtree// once. This preserves rewrite order and bytes without copying the full request// for every declaration schema.func sanitizeAntigravityToolSchemas(payloadStr string, useAntigravitySchema bool) string { tools := gjson.Get(payloadStr, "request.tools") if !tools.IsArray() { return payloadStr }
toolDocument := `{"request":{"tools":` + tools.Raw + `}}` toolDocument = sanitizeAntigravityToolSchemaDocument(toolDocument, useAntigravitySchema) cleanedTools := gjson.Get(toolDocument, "request.tools") if !cleanedTools.IsArray() || cleanedTools.Raw == tools.Raw { return payloadStr } updated, errSet := sjson.SetRawBytes([]byte(payloadStr), "request.tools", []byte(cleanedTools.Raw)) if errSet != nil { log.Debugf("antigravity: failed to write cleaned request.tools: %v", errSet) return payloadStr } return string(updated)}
func sanitizeAntigravityToolSchemaDocument(payloadStr string, useAntigravitySchema bool) string { for _, base := range antigravityFunctionDeclarationPaths(payloadStr) { oldPath := base + ".parametersJsonSchema" if !gjson.Get(payloadStr, oldPath).Exists() { continue } renamed, errRename := util.RenameKey(payloadStr, oldPath, base+".parameters") if errRename != nil { log.Debugf("antigravity: failed to rename %s: %v", oldPath, errRename) continue } payloadStr = renamed }
toolSchemaCleaner := func(schema string) string { return util.CleanJSONSchemaForAntigravityTool(schema, useAntigravitySchema) } cleanNestedToolSchema := func(schemaRaw string) string { return cleanNestedSchema(toolSchemaCleaner, schemaRaw) } return cleanAntigravitySchemasAtPaths( payloadStr, antigravityDeclarationSchemaPaths(payloadStr), cleanNestedToolSchema, )}
// sanitizeAntigravityGenerationSchemas batches every schema edit within one// generation config before replacing that config in the full request.func sanitizeAntigravityGenerationSchemas(payloadStr string) string { for _, container := range antigravityGenerationConfigContainers { generationConfig := gjson.Get(payloadStr, container) if !generationConfig.IsObject() { continue } cleanedConfig := generationConfig.Raw for _, key := range antigravityGenerationSchemaKeys { schema := gjson.Get(cleanedConfig, key) if !schema.IsObject() { continue } cleanedSchema := util.CleanJSONSchemaForAntigravityResponse(schema.Raw) if cleanedSchema == schema.Raw { continue } updated, errSet := sjson.SetRawBytes([]byte(cleanedConfig), key, []byte(cleanedSchema)) if errSet != nil { log.Debugf("antigravity: failed to write cleaned schema at %s.%s: %v", container, key, errSet) continue } cleanedConfig = string(updated) } if cleanedConfig == generationConfig.Raw { continue } updated, errSet := sjson.SetRawBytes([]byte(payloadStr), container, []byte(cleanedConfig)) if errSet != nil { log.Debugf("antigravity: failed to write cleaned %s: %v", container, errSet) continue } payloadStr = string(updated) } return payloadStr}
func cleanAntigravitySchemasAtPaths(payloadStr string, schemaPaths []string, clean func(string) string) string { for _, schemaPath := range schemaPaths { schema := gjson.Get(payloadStr, schemaPath) if !schema.Exists() { continue } cleanedSchema := clean(schema.Raw) if cleanedSchema == schema.Raw { continue } updated, errSet := sjson.SetRawBytes([]byte(payloadStr), schemaPath, []byte(cleanedSchema)) if errSet != nil { log.Debugf("antigravity: failed to write cleaned schema at %s: %v", schemaPath, errSet) continue } payloadStr = string(updated) } return payloadStr}
// antigravitySchemaWrapperKey nests a schema during cleaning. It is never sent upstream.const antigravitySchemaWrapperKey = "schema"
// cleanNestedSchema cleans a schema with it nested one level down, then unwraps it.//// The cleaner deliberately skips placeholder insertion for a top-level schema, but Claude's// VALIDATED mode needs every tool schema to declare at least one required property. Whole-payload// cleaning always saw tool schemas nested inside the request, so nesting is reproduced here to keep// the emitted schema byte-identical to the previous behaviour.func cleanNestedSchema(clean func(string) string, schemaRaw string) string { wrapped, errWrap := sjson.SetRaw("{}", antigravitySchemaWrapperKey, schemaRaw) if errWrap != nil { return clean(schemaRaw) } if unwrapped := gjson.Get(clean(wrapped), antigravitySchemaWrapperKey); unwrapped.Exists() { return unwrapped.Raw } return clean(schemaRaw)}
// antigravityFunctionDeclarationPaths returns the path of every function declaration in the request.// Both the camelCase and snake_case spellings are accepted because callers reach this executor// through different translators.func antigravityFunctionDeclarationPaths(payloadStr string) []string { tools := gjson.Get(payloadStr, "request.tools") if !tools.IsArray() { return nil } paths := make([]string, 0, len(tools.Array())) for i, tool := range tools.Array() { for _, declKey := range []string{"functionDeclarations", "function_declarations"} { decls := tool.Get(declKey) if !decls.IsArray() { continue } for j := range decls.Array() { paths = append(paths, fmt.Sprintf("request.tools.%d.%s.%d", i, declKey, j)) } } } return paths}
// antigravitySchemaPaths returns every payload path that holds a JSON schema document.// A function declaration may carry a schema for its parameters and for its result, so all of// them must be cleaned; anything omitted here reaches the upstream API uncleaned.func antigravitySchemaPaths(payloadStr string) []string { paths := antigravityDeclarationSchemaPaths(payloadStr) return append(paths, antigravityGenerationSchemaPaths(payloadStr)...)}
func antigravityDeclarationSchemaPaths(payloadStr string) []string { paths := make([]string, 0, 8) for _, base := range antigravityFunctionDeclarationPaths(payloadStr) { for _, key := range antigravityDeclarationSchemaKeys { if gjson.Get(payloadStr, base+"."+key).IsObject() { paths = append(paths, base+"."+key) } } } return paths}
func antigravityGenerationSchemaPaths(payloadStr string) []string { paths := make([]string, 0, len(antigravityGenerationConfigContainers)*len(antigravityGenerationSchemaKeys)) for _, container := range antigravityGenerationConfigContainers { for _, key := range antigravityGenerationSchemaKeys { path := container + "." + key if gjson.Get(payloadStr, path).IsObject() { paths = append(paths, path) } } } return paths}
// The upstream API is proto-JSON and accepts either spelling, and the Gemini translator forwards// whichever one the client sent. Both are therefore cleaned where they sit rather than renamed:// renaming would alter the body the client asked for, and only the unsupported keywords inside a// schema cause upstream errors. The one exception is parametersJsonSchema, renamed onto parameters// above because whole-payload cleaning did the same.var ( antigravityDeclarationSchemaKeys = []string{ "parameters", "parametersJsonSchema", "parameters_json_schema", "response", "responseJsonSchema", "response_json_schema", } antigravityGenerationConfigContainers = []string{ "request.generationConfig", "request.generation_config", } antigravityGenerationSchemaKeys = []string{ "responseSchema", "responseJsonSchema", "response_schema", "response_json_schema", })
func antigravityRequestNeedsSchemaSanitization(payload []byte) bool { if gjson.GetBytes(payload, "request.tools.0").Exists() { return true } for _, container := range antigravityGenerationConfigContainers { for _, key := range antigravityGenerationSchemaKeys { if gjson.GetBytes(payload, container+"."+key).Exists() { return true } } } return false}
// resolveAntigravityRequestBaseURL selects one request endpoint without cross-tier fallback.// Consumer credentials default to daily; enterprise/GCP credentials can set base_url explicitly.func resolveAntigravityRequestBaseURL(auth *cliproxyauth.Auth) string { if base := resolveCustomAntigravityBaseURL(auth); base != "" { return base } return antigravityBaseURLDaily}
func antigravityLoadCodeAssistBaseURL(auth *cliproxyauth.Auth) string { if base := resolveCustomAntigravityBaseURL(auth); base != "" { return base } return antigravityBaseURLProd}
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 { return misc.AntigravityRequestUserAgent(antigravityConfiguredUserAgent(auth))}
func resolveLoadCodeAssistUserAgent(auth *cliproxyauth.Auth) string { return misc.AntigravityLoadCodeAssistUserAgent(antigravityConfiguredUserAgent(auth))}
func antigravityConfiguredUserAgent(auth *cliproxyauth.Auth) string { raw := "" if auth != nil { if auth.Attributes != nil { if ua := strings.TrimSpace(auth.Attributes["user_agent"]); ua != "" { raw = ua } } if raw == "" && auth.Metadata != nil { if ua, ok := auth.Metadata["user_agent"].(string); ok && strings.TrimSpace(ua) != "" { raw = strings.TrimSpace(ua) } } } return raw}
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, derivedSessionIDs ...string) []byte { template := payload template = helps.SetStringIfDifferent(template, "model", modelName) template = helps.SetStringIfDifferent(template, "userAgent", "antigravity")
isImageModel := strings.Contains(modelName, "image") reqType := strings.TrimSpace(gjson.GetBytes(template, "requestType").String()) if reqType == "" { if isImageModel { reqType = "image_gen" } else { reqType = "agent" } template, _ = sjson.SetBytes(template, "requestType", reqType) }
if projectID != "" { template = helps.SetStringIfDifferent(template, "project", projectID) } else { template, _ = sjson.DeleteBytes(template, "project") }
if isImageModel { template, _ = sjson.SetBytes(template, "requestId", generateImageGenRequestID()) } else if reqType != "web_search" { template, _ = sjson.SetBytes(template, "requestId", generateRequestID()) sessionID := strings.TrimSpace(gjson.GetBytes(template, "request.sessionId").String()) if sessionID == "" && len(derivedSessionIDs) > 0 { sessionID = strings.TrimSpace(derivedSessionIDs[0]) } if sessionID == "" { sessionID = generateStableSessionID(payload) } template, _ = sjson.SetBytes(template, "request.sessionId", sessionID) }
template, _ = sjson.DeleteBytes(template, "request.safetySettings") if toolConfig := gjson.GetBytes(template, "toolConfig"); toolConfig.Exists() && !gjson.GetBytes(template, "request.toolConfig").Exists() { template, _ = sjson.SetRawBytes(template, "request.toolConfig", []byte(toolConfig.Raw)) template, _ = sjson.DeleteBytes(template, "toolConfig") } return template}
func generateRequestID() string { return "agent-" + uuid.NewString()}
func generateImageGenRequestID() string { return fmt.Sprintf("image_gen/%d/%s/12", time.Now().UnixMilli(), 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 := util.GetGJSONBytesNoCopy(payload, "request.contents") if !contents.IsArray() { return generateSessionID() }
stableID := "" contents.ForEach(func(_, content gjson.Result) bool { if content.Get("role").String() != "user" { return true } text := content.Get("parts.0.text").String() if text == "" { return true } hash := sha256.Sum256([]byte(text)) value := int64(binary.BigEndian.Uint64(hash[:8])) & 0x7FFFFFFFFFFFFFFF stableID = "-" + strconv.FormatInt(value, 10) return false }) if stableID != "" { return stableID } return generateSessionID()}