diff --git a/internal/runtime/executor/antigravity_executor.go b/internal/runtime/executor/antigravity_executor.go index 19fbb7b6..e3b2c2b4 100644 --- a/internal/runtime/executor/antigravity_executor.go +++ b/internal/runtime/executor/antigravity_executor.go @@ -148,7 +148,7 @@ func (e *AntigravityExecutor) Execute(ctx context.Context, auth *cliproxyauth.Au baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - attempts := antigravityRetryAttempts(e.cfg) + attempts := antigravityRetryAttempts(auth, e.cfg) attemptLoop: for attempt := 0; attempt < attempts; attempt++ { @@ -289,7 +289,7 @@ func (e *AntigravityExecutor) executeClaudeNonStream(ctx context.Context, auth * baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - attempts := antigravityRetryAttempts(e.cfg) + attempts := antigravityRetryAttempts(auth, e.cfg) attemptLoop: for attempt := 0; attempt < attempts; attempt++ { @@ -677,7 +677,7 @@ func (e *AntigravityExecutor) ExecuteStream(ctx context.Context, auth *cliproxya baseURLs := antigravityBaseURLFallbackOrder(auth) httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0) - attempts := antigravityRetryAttempts(e.cfg) + attempts := antigravityRetryAttempts(auth, e.cfg) attemptLoop: for attempt := 0; attempt < attempts; attempt++ { @@ -1447,11 +1447,16 @@ func resolveUserAgent(auth *cliproxyauth.Auth) string { return defaultAntigravityAgent } -func antigravityRetryAttempts(cfg *config.Config) int { - if cfg == nil { - return 1 +func antigravityRetryAttempts(auth *cliproxyauth.Auth, cfg *config.Config) int { + retry := 0 + if cfg != nil { + retry = cfg.RequestRetry + } + if auth != nil { + if override, ok := auth.RequestRetryOverride(); ok { + retry = override + } } - retry := cfg.RequestRetry if retry < 0 { retry = 0 } @@ -1590,7 +1595,8 @@ func generateProjectID() string { return adj + "-" + noun + "-" + randomPart } -// Embed is not supported by the antigravity executor. +// Embed is a stub to satisfy the ProviderExecutor interface. +// Antigravity does not support embeddings. func (e *AntigravityExecutor) Embed(context.Context, *cliproxyauth.Auth, cliproxyexecutor.Request, cliproxyexecutor.Options) (cliproxyexecutor.Response, error) { return cliproxyexecutor.Response{}, fmt.Errorf("antigravity executor does not support embeddings") } diff --git a/internal/util/gemini_schema.go b/internal/util/gemini_schema.go index 867dd4fa..60453998 100644 --- a/internal/util/gemini_schema.go +++ b/internal/util/gemini_schema.go @@ -175,7 +175,7 @@ func convertConstToEnum(jsonStr string) string { return jsonStr } -// convertEnumValuesToStrings ensures all enum values are strings. +// convertEnumValuesToStrings ensures all enum values are strings and the schema type is set to string. // Gemini API requires enum values to be of type string, not numbers or booleans. func convertEnumValuesToStrings(jsonStr string) string { for _, p := range findPaths(jsonStr, "enum") { @@ -185,19 +185,15 @@ func convertEnumValuesToStrings(jsonStr string) string { } var stringVals []string - needsConversion := false for _, item := range arr.Array() { - // Check if any value is not a string - if item.Type != gjson.String { - needsConversion = true - } stringVals = append(stringVals, item.String()) } - // Only update if we found non-string values - if needsConversion { - jsonStr, _ = sjson.Set(jsonStr, p, stringVals) - } + // Always update enum values to strings and set type to "string" + // This ensures compatibility with Antigravity Gemini which only allows enum for STRING type + jsonStr, _ = sjson.Set(jsonStr, p, stringVals) + parentPath := trimSuffix(p, ".enum") + jsonStr, _ = sjson.Set(jsonStr, joinPath(parentPath, "type"), "string") } return jsonStr } diff --git a/internal/watcher/synthesizer/file.go b/internal/watcher/synthesizer/file.go index 190d310a..ef0eb8c9 100644 --- a/internal/watcher/synthesizer/file.go +++ b/internal/watcher/synthesizer/file.go @@ -167,6 +167,16 @@ func SynthesizeGeminiVirtualAuths(primary *coreauth.Auth, metadata map[string]an "virtual_parent_id": primary.ID, "type": metadata["type"], } + if v, ok := metadata["disable_cooling"]; ok { + metadataCopy["disable_cooling"] = v + } else if v, ok := metadata["disable-cooling"]; ok { + metadataCopy["disable_cooling"] = v + } + if v, ok := metadata["request_retry"]; ok { + metadataCopy["request_retry"] = v + } else if v, ok := metadata["request-retry"]; ok { + metadataCopy["request_retry"] = v + } proxy := strings.TrimSpace(primary.ProxyURL) if proxy != "" { metadataCopy["proxy_url"] = proxy diff --git a/internal/watcher/synthesizer/file_test.go b/internal/watcher/synthesizer/file_test.go index 2e9d5f07..93025fba 100644 --- a/internal/watcher/synthesizer/file_test.go +++ b/internal/watcher/synthesizer/file_test.go @@ -69,10 +69,12 @@ func TestFileSynthesizer_Synthesize_ValidAuthFile(t *testing.T) { // Create a valid auth file authData := map[string]any{ - "type": "claude", - "email": "test@example.com", - "proxy_url": "http://proxy.local", - "prefix": "test-prefix", + "type": "claude", + "email": "test@example.com", + "proxy_url": "http://proxy.local", + "prefix": "test-prefix", + "disable_cooling": true, + "request_retry": 2, } data, _ := json.Marshal(authData) err := os.WriteFile(filepath.Join(tempDir, "claude-auth.json"), data, 0644) @@ -108,6 +110,12 @@ func TestFileSynthesizer_Synthesize_ValidAuthFile(t *testing.T) { if auths[0].ProxyURL != "http://proxy.local" { t.Errorf("expected proxy_url http://proxy.local, got %s", auths[0].ProxyURL) } + if v, ok := auths[0].Metadata["disable_cooling"].(bool); !ok || !v { + t.Errorf("expected disable_cooling true, got %v", auths[0].Metadata["disable_cooling"]) + } + if v, ok := auths[0].Metadata["request_retry"].(float64); !ok || int(v) != 2 { + t.Errorf("expected request_retry 2, got %v", auths[0].Metadata["request_retry"]) + } if auths[0].Status != coreauth.StatusActive { t.Errorf("expected status active, got %s", auths[0].Status) } @@ -336,9 +344,11 @@ func TestSynthesizeGeminiVirtualAuths_MultiProject(t *testing.T) { }, } metadata := map[string]any{ - "project_id": "project-a, project-b, project-c", - "email": "test@example.com", - "type": "gemini", + "project_id": "project-a, project-b, project-c", + "email": "test@example.com", + "type": "gemini", + "request_retry": 2, + "disable_cooling": true, } virtuals := SynthesizeGeminiVirtualAuths(primary, metadata, now) @@ -376,6 +386,12 @@ func TestSynthesizeGeminiVirtualAuths_MultiProject(t *testing.T) { if v.ProxyURL != "http://proxy.local" { t.Errorf("expected proxy_url http://proxy.local, got %s", v.ProxyURL) } + if vv, ok := v.Metadata["disable_cooling"].(bool); !ok || !vv { + t.Errorf("expected disable_cooling true, got %v", v.Metadata["disable_cooling"]) + } + if vv, ok := v.Metadata["request_retry"].(int); !ok || vv != 2 { + t.Errorf("expected request_retry 2, got %v", v.Metadata["request_retry"]) + } if v.Attributes["runtime_only"] != "true" { t.Error("expected runtime_only=true") } diff --git a/sdk/auth/filestore.go b/sdk/auth/filestore.go index ad3bd207..77b24db4 100644 --- a/sdk/auth/filestore.go +++ b/sdk/auth/filestore.go @@ -8,7 +8,6 @@ import ( "net/http" "os" "path/filepath" - "reflect" "strings" "sync" "time" @@ -74,28 +73,26 @@ func (s *FileTokenStore) Save(ctx context.Context, auth *cliproxyauth.Auth) (str return "", fmt.Errorf("auth filestore: marshal metadata failed: %w", errMarshal) } if existing, errRead := os.ReadFile(path); errRead == nil { - // Use metadataEqualIgnoringTimestamps to skip writes when only timestamp fields change. - // This prevents the token refresh loop caused by timestamp/expired/expires_in changes. - if metadataEqualIgnoringTimestamps(existing, raw) { + if jsonEqual(existing, raw) { return path, nil } file, errOpen := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0o600) if errOpen != nil { - return "", fmt.Errorf("auth filestore: open file failed: %w", errOpen) + return "", fmt.Errorf("auth filestore: open existing failed: %w", errOpen) } if _, errWrite := file.Write(raw); errWrite != nil { _ = file.Close() - return "", fmt.Errorf("auth filestore: write failed: %w", errWrite) + return "", fmt.Errorf("auth filestore: write existing failed: %w", errWrite) } if errClose := file.Close(); errClose != nil { - return "", fmt.Errorf("auth filestore: close failed: %w", errClose) + return "", fmt.Errorf("auth filestore: close existing failed: %w", errClose) } - } else if errRead != nil && !os.IsNotExist(errRead) { + return path, nil + } else if !os.IsNotExist(errRead) { return "", fmt.Errorf("auth filestore: read existing failed: %w", errRead) - } else { - if errWrite := os.WriteFile(path, raw, 0o600); errWrite != nil { - return "", fmt.Errorf("auth filestore: write failed: %w", errWrite) - } + } + if errWrite := os.WriteFile(path, raw, 0o600); errWrite != nil { + return "", fmt.Errorf("auth filestore: write file failed: %w", errWrite) } default: return "", fmt.Errorf("auth filestore: nothing to persist for %s", auth.ID) @@ -188,13 +185,17 @@ func (s *FileTokenStore) readAuthFile(path, baseDir string) (*cliproxyauth.Auth, if provider == "" { provider = "unknown" } - - // For antigravity provider, auto-fetch project_id if missing if provider == "antigravity" { - projectID, _ := metadata["project_id"].(string) - if strings.TrimSpace(projectID) == "" { - accessToken, _ := metadata["access_token"].(string) - if strings.TrimSpace(accessToken) != "" { + projectID := "" + if pid, ok := metadata["project_id"].(string); ok { + projectID = strings.TrimSpace(pid) + } + if projectID == "" { + accessToken := "" + if token, ok := metadata["access_token"].(string); ok { + accessToken = strings.TrimSpace(token) + } + if accessToken != "" { fetchedProjectID, errFetch := FetchAntigravityProjectID(context.Background(), accessToken, http.DefaultClient) if errFetch == nil && strings.TrimSpace(fetchedProjectID) != "" { metadata["project_id"] = strings.TrimSpace(fetchedProjectID) @@ -208,7 +209,6 @@ func (s *FileTokenStore) readAuthFile(path, baseDir string) (*cliproxyauth.Auth, } } } - info, err := os.Stat(path) if err != nil { return nil, fmt.Errorf("stat file: %w", err) @@ -230,10 +230,6 @@ func (s *FileTokenStore) readAuthFile(path, baseDir string) (*cliproxyauth.Auth, if email, ok := metadata["email"].(string); ok && email != "" { auth.Attributes["email"] = email } - // Extract token expiry for proactive refresh scheduling. - if expiry, ok := auth.ExpirationTime(); ok { - auth.TokenExpiresAt = expiry - } return auth, nil } @@ -301,31 +297,65 @@ func (s *FileTokenStore) baseDirSnapshot() string { return s.baseDir } -// metadataEqualIgnoringTimestamps compares two metadata JSON blobs, -// ignoring volatile fields that change on every refresh. -// This prevents unnecessary file writes that would trigger watcher reload loops. -func metadataEqualIgnoringTimestamps(a, b []byte) bool { - var objA map[string]any - var objB map[string]any - if errUnmarshalA := json.Unmarshal(a, &objA); errUnmarshalA != nil { +// jsonEqual compares two JSON blobs by parsing them into Go objects and deep comparing. +func jsonEqual(a, b []byte) bool { + var objA any + var objB any + if err := json.Unmarshal(a, &objA); err != nil { return false } - if errUnmarshalB := json.Unmarshal(b, &objB); errUnmarshalB != nil { + if err := json.Unmarshal(b, &objB); err != nil { return false } - stripVolatileMetadataFields(objA) - stripVolatileMetadataFields(objB) - return reflect.DeepEqual(objA, objB) + return deepEqualJSON(objA, objB) } -// stripVolatileMetadataFields removes fields that change on every token refresh -// but don't affect authentication logic. -func stripVolatileMetadataFields(metadata map[string]any) { - if metadata == nil { - return - } - // These fields change on refresh and would otherwise trigger watcher reload loops. - for _, field := range []string{"timestamp", "expired", "expires_in", "last_refresh", "access_token"} { - delete(metadata, field) +func deepEqualJSON(a, b any) bool { + switch valA := a.(type) { + case map[string]any: + valB, ok := b.(map[string]any) + if !ok || len(valA) != len(valB) { + return false + } + for key, subA := range valA { + subB, ok1 := valB[key] + if !ok1 || !deepEqualJSON(subA, subB) { + return false + } + } + return true + case []any: + sliceB, ok := b.([]any) + if !ok || len(valA) != len(sliceB) { + return false + } + for i := range valA { + if !deepEqualJSON(valA[i], sliceB[i]) { + return false + } + } + return true + case float64: + valB, ok := b.(float64) + if !ok { + return false + } + return valA == valB + case string: + valB, ok := b.(string) + if !ok { + return false + } + return valA == valB + case bool: + valB, ok := b.(bool) + if !ok { + return false + } + return valA == valB + case nil: + return b == nil + default: + return false } } diff --git a/sdk/cliproxy/auth/types.go b/sdk/cliproxy/auth/types.go index f1691699..98042a72 100644 --- a/sdk/cliproxy/auth/types.go +++ b/sdk/cliproxy/auth/types.go @@ -218,6 +218,108 @@ func (a *Auth) ProxyInfo() string { return "via proxy" } +// DisableCoolingOverride returns the auth-file scoped disable_cooling override when present. +// The value is read from metadata key "disable_cooling" (or legacy "disable-cooling"). +func (a *Auth) DisableCoolingOverride() (bool, bool) { + if a == nil || a.Metadata == nil { + return false, false + } + if val, ok := a.Metadata["disable_cooling"]; ok { + if parsed, okParse := parseBoolAny(val); okParse { + return parsed, true + } + } + if val, ok := a.Metadata["disable-cooling"]; ok { + if parsed, okParse := parseBoolAny(val); okParse { + return parsed, true + } + } + return false, false +} + +// RequestRetryOverride returns the auth-file scoped request_retry override when present. +// The value is read from metadata key "request_retry" (or legacy "request-retry"). +func (a *Auth) RequestRetryOverride() (int, bool) { + if a == nil || a.Metadata == nil { + return 0, false + } + if val, ok := a.Metadata["request_retry"]; ok { + if parsed, okParse := parseIntAny(val); okParse { + if parsed < 0 { + parsed = 0 + } + return parsed, true + } + } + if val, ok := a.Metadata["request-retry"]; ok { + if parsed, okParse := parseIntAny(val); okParse { + if parsed < 0 { + parsed = 0 + } + return parsed, true + } + } + return 0, false +} + +func parseBoolAny(val any) (bool, bool) { + switch typed := val.(type) { + case bool: + return typed, true + case string: + trimmed := strings.TrimSpace(typed) + if trimmed == "" { + return false, false + } + parsed, err := strconv.ParseBool(trimmed) + if err != nil { + return false, false + } + return parsed, true + case float64: + return typed != 0, true + case json.Number: + parsed, err := typed.Int64() + if err != nil { + return false, false + } + return parsed != 0, true + default: + return false, false + } +} + +func parseIntAny(val any) (int, bool) { + switch typed := val.(type) { + case int: + return typed, true + case int32: + return int(typed), true + case int64: + return int(typed), true + case float64: + return int(typed), true + case json.Number: + parsed, err := typed.Int64() + if err != nil { + return 0, false + } + return int(parsed), true + case string: + trimmed := strings.TrimSpace(typed) + if trimmed == "" { + return 0, false + } + parsed, err := strconv.Atoi(trimmed) + if err != nil { + return 0, false + } + return parsed, true + default: + return 0, false + } +} + func (a *Auth) AccountInfo() (string, string) { if a == nil { return "", ""