diff --git a/internal/cache/signature_cache.go b/internal/cache/signature_cache.go index d64dbded..69c5b701 100644 --- a/internal/cache/signature_cache.go +++ b/internal/cache/signature_cache.go @@ -3,8 +3,6 @@ package cache import ( "crypto/sha256" "encoding/hex" - "fmt" - "sort" "strings" "sync" "time" @@ -17,30 +15,27 @@ type SignatureEntry struct { } const ( - // SignatureCacheTTL is how long signatures are valid + // SignatureCacheTTL is how long signatures are valid (reduced from 3h for memory efficiency) SignatureCacheTTL = 1 * time.Hour - // MaxEntriesPerSession limits memory usage per session - MaxEntriesPerSession = 100 - // SignatureTextHashLen is the length of the hash key (16 hex chars = 64-bit key space) SignatureTextHashLen = 16 // MinValidSignatureLen is the minimum length for a signature to be considered valid MinValidSignatureLen = 50 - // SessionCleanupInterval controls how often stale sessions are purged - SessionCleanupInterval = 10 * time.Minute + // CacheCleanupInterval controls how often stale entries are purged + CacheCleanupInterval = 10 * time.Minute ) -// signatureCache stores signatures by textHash -> SignatureEntry +// signatureCache stores signatures by model group -> textHash -> SignatureEntry var signatureCache sync.Map -// sessionCleanupOnce ensures the background cleanup goroutine starts only once -var sessionCleanupOnce sync.Once +// cacheCleanupOnce ensures the background cleanup goroutine starts only once +var cacheCleanupOnce sync.Once -// sessionCache is the inner map type -type sessionCache struct { +// groupCache is the inner map type +type groupCache struct { mu sync.RWMutex entries map[string]SignatureEntry } @@ -51,36 +46,36 @@ func hashText(text string) string { return hex.EncodeToString(h[:])[:SignatureTextHashLen] } -// getOrCreateSession gets or creates a session cache -func getOrCreateSession(sessionID string) *sessionCache { +// getOrCreateGroupCache gets or creates a cache bucket for a model group +func getOrCreateGroupCache(groupKey string) *groupCache { // Start background cleanup on first access - sessionCleanupOnce.Do(startSessionCleanup) + cacheCleanupOnce.Do(startCacheCleanup) - if val, ok := signatureCache.Load(sessionID); ok { - return val.(*sessionCache) + if val, ok := signatureCache.Load(groupKey); ok { + return val.(*groupCache) } - sc := &sessionCache{entries: make(map[string]SignatureEntry)} - actual, _ := signatureCache.LoadOrStore(sessionID, sc) - return actual.(*sessionCache) + sc := &groupCache{entries: make(map[string]SignatureEntry)} + actual, _ := signatureCache.LoadOrStore(groupKey, sc) + return actual.(*groupCache) } -// startSessionCleanup launches a background goroutine that periodically -// removes sessions where all entries have expired. -func startSessionCleanup() { +// startCacheCleanup launches a background goroutine that periodically +// removes caches where all entries have expired. +func startCacheCleanup() { go func() { - ticker := time.NewTicker(SessionCleanupInterval) + ticker := time.NewTicker(CacheCleanupInterval) defer ticker.Stop() for range ticker.C { - purgeExpiredSessions() + purgeExpiredCaches() } }() } -// purgeExpiredSessions removes sessions with no valid (non-expired) entries. -func purgeExpiredSessions() { +// purgeExpiredCaches removes caches with no valid (non-expired) entries. +func purgeExpiredCaches() { now := time.Now() signatureCache.Range(func(key, value any) bool { - sc := value.(*sessionCache) + sc := value.(*groupCache) sc.mu.Lock() // Remove expired entries for k, entry := range sc.entries { @@ -90,7 +85,7 @@ func purgeExpiredSessions() { } isEmpty := len(sc.entries) == 0 sc.mu.Unlock() - // Remove session if empty + // Remove cache bucket if empty if isEmpty { signatureCache.Delete(key) } @@ -98,7 +93,7 @@ func purgeExpiredSessions() { }) } -// CacheSignature stores a thinking signature for a given model and text. +// CacheSignature stores a thinking signature for a given model group and text. // Used for Claude models that require signed thinking blocks in multi-turn conversations. func CacheSignature(modelName, text, signature string) { if text == "" || signature == "" { @@ -108,87 +103,47 @@ func CacheSignature(modelName, text, signature string) { return } - text = fmt.Sprintf("%s#%s", GetModelGroup(modelName), text) + groupKey := GetModelGroup(modelName) textHash := hashText(text) - sc := getOrCreateSession(textHash) - + sc := getOrCreateGroupCache(groupKey) sc.mu.Lock() defer sc.mu.Unlock() - // Evict expired entries if at capacity - if len(sc.entries) >= MaxEntriesPerSession { - now := time.Now() - for key, entry := range sc.entries { - if now.Sub(entry.Timestamp) > SignatureCacheTTL { - delete(sc.entries, key) - } - } - // If still at capacity, remove oldest entries - if len(sc.entries) >= MaxEntriesPerSession { - // Find and remove oldest quarter - oldest := make([]struct { - key string - ts time.Time - }, 0, len(sc.entries)) - for key, entry := range sc.entries { - oldest = append(oldest, struct { - key string - ts time.Time - }{key, entry.Timestamp}) - } - // Sort by timestamp (oldest first) using sort.Slice - sort.Slice(oldest, func(i, j int) bool { - return oldest[i].ts.Before(oldest[j].ts) - }) - - toRemove := len(oldest) / 4 - if toRemove < 1 { - toRemove = 1 - } - - for i := 0; i < toRemove; i++ { - delete(sc.entries, oldest[i].key) - } - } - } - sc.entries[textHash] = SignatureEntry{ Signature: signature, Timestamp: time.Now(), } } -// GetCachedSignature retrieves a cached signature for a given model and text. +// GetCachedSignature retrieves a cached signature for a given model group and text. // Returns empty string if not found or expired. -// For gemini models, returns "skip_thought_signature_validator" as fallback. func GetCachedSignature(modelName, text string) string { - family := GetModelGroup(modelName) + groupKey := GetModelGroup(modelName) if text == "" { - if family == "gemini" { + if groupKey == "gemini" { return "skip_thought_signature_validator" } return "" } - - text = fmt.Sprintf("%s#%s", GetModelGroup(modelName), text) - val, ok := signatureCache.Load(hashText(text)) + val, ok := signatureCache.Load(groupKey) if !ok { - if family == "gemini" { + if groupKey == "gemini" { return "skip_thought_signature_validator" } return "" } - sc := val.(*sessionCache) + sc := val.(*groupCache) textHash := hashText(text) + now := time.Now() sc.mu.Lock() entry, exists := sc.entries[textHash] if !exists { sc.mu.Unlock() - if family == "gemini" { + if groupKey == "gemini" { return "skip_thought_signature_validator" } return "" @@ -196,13 +151,13 @@ func GetCachedSignature(modelName, text string) string { if now.Sub(entry.Timestamp) > SignatureCacheTTL { delete(sc.entries, textHash) sc.mu.Unlock() - if family == "gemini" { + if groupKey == "gemini" { return "skip_thought_signature_validator" } return "" } - // Refresh TTL on access (sliding expiration) + // Refresh TTL on access (sliding expiration). entry.Timestamp = now sc.entries[textHash] = entry sc.mu.Unlock() @@ -210,22 +165,17 @@ func GetCachedSignature(modelName, text string) string { return entry.Signature } -// ClearSignatureCache clears signature cache for a specific session or all sessions. -func ClearSignatureCache(sessionID string) { - if sessionID != "" { - signatureCache.Range(func(key, _ any) bool { - kStr, ok := key.(string) - if ok && strings.HasSuffix(kStr, "#"+sessionID) { - signatureCache.Delete(key) - } - return true - }) - } else { +// ClearSignatureCache clears signature cache for a specific model group or all groups. +func ClearSignatureCache(modelName string) { + if modelName == "" { signatureCache.Range(func(key, _ any) bool { signatureCache.Delete(key) return true }) + return } + groupKey := GetModelGroup(modelName) + signatureCache.Delete(groupKey) } // HasValidSignature checks if a signature is valid (non-empty and long enough) diff --git a/internal/cache/signature_cache_test.go b/internal/cache/signature_cache_test.go index 5e92dd04..83408159 100644 --- a/internal/cache/signature_cache_test.go +++ b/internal/cache/signature_cache_test.go @@ -5,6 +5,8 @@ import ( "time" ) +const testModelName = "claude-sonnet-4-5" + func TestCacheSignature_BasicStorageAndRetrieval(t *testing.T) { ClearSignatureCache("") @@ -12,45 +14,45 @@ func TestCacheSignature_BasicStorageAndRetrieval(t *testing.T) { signature := "abc123validSignature1234567890123456789012345678901234567890" // Store signature - CacheSignature("test-model", text, signature) + CacheSignature(testModelName, text, signature) // Retrieve signature - retrieved := GetCachedSignature("test-model", text) + retrieved := GetCachedSignature(testModelName, text) if retrieved != signature { t.Errorf("Expected signature '%s', got '%s'", signature, retrieved) } } -func TestCacheSignature_DifferentTexts(t *testing.T) { +func TestCacheSignature_DifferentModelGroups(t *testing.T) { ClearSignatureCache("") - text1 := "First text" - text2 := "Second text" + text := "Same text across models" sig1 := "signature1_1234567890123456789012345678901234567890123456" sig2 := "signature2_1234567890123456789012345678901234567890123456" - CacheSignature("test-model", text1, sig1) - CacheSignature("test-model", text2, sig2) + geminiModel := "gemini-3-pro-preview" + CacheSignature(testModelName, text, sig1) + CacheSignature(geminiModel, text, sig2) - if GetCachedSignature("test-model", text1) != sig1 { - t.Error("text1 signature mismatch") + if GetCachedSignature(testModelName, text) != sig1 { + t.Error("Claude signature mismatch") } - if GetCachedSignature("test-model", text2) != sig2 { - t.Error("text2 signature mismatch") + if GetCachedSignature(geminiModel, text) != sig2 { + t.Error("Gemini signature mismatch") } } func TestCacheSignature_NotFound(t *testing.T) { ClearSignatureCache("") - // Non-existent text - if got := GetCachedSignature("test-model", "some text"); got != "" { - t.Errorf("Expected empty string for nonexistent text, got '%s'", got) + // Non-existent session + if got := GetCachedSignature(testModelName, "some text"); got != "" { + t.Errorf("Expected empty string for nonexistent session, got '%s'", got) } - // Existing text but different model (should still find due to model group) - CacheSignature("test-model", "text-a", "sigA12345678901234567890123456789012345678901234567890") - if got := GetCachedSignature("test-model", "text-b"); got != "" { + // Existing session but different text + CacheSignature(testModelName, "text-a", "sigA12345678901234567890123456789012345678901234567890") + if got := GetCachedSignature(testModelName, "text-b"); got != "" { t.Errorf("Expected empty string for different text, got '%s'", got) } } @@ -58,14 +60,12 @@ func TestCacheSignature_NotFound(t *testing.T) { func TestCacheSignature_EmptyInputs(t *testing.T) { ClearSignatureCache("") - // Empty text should not cache - CacheSignature("test-model", "", "sig12345678901234567890123456789012345678901234567890") - // Empty signature should not cache - CacheSignature("test-model", "valid-text", "") - // Short signature should not cache - CacheSignature("test-model", "valid-text", "short") + // All empty/invalid inputs should be no-ops + CacheSignature(testModelName, "", "sig12345678901234567890123456789012345678901234567890") + CacheSignature(testModelName, "text", "") + CacheSignature(testModelName, "text", "short") // Too short - if got := GetCachedSignature("test-model", "valid-text"); got != "" { + if got := GetCachedSignature(testModelName, "text"); got != "" { t.Errorf("Expected empty after invalid cache attempts, got '%s'", got) } } @@ -76,27 +76,41 @@ func TestCacheSignature_ShortSignatureRejected(t *testing.T) { text := "Some text" shortSig := "abc123" // Less than 50 chars - CacheSignature("test-model", text, shortSig) + CacheSignature(testModelName, text, shortSig) - if got := GetCachedSignature("test-model", text); got != "" { + if got := GetCachedSignature(testModelName, text); got != "" { t.Errorf("Short signature should be rejected, got '%s'", got) } } +func TestClearSignatureCache_ModelGroup(t *testing.T) { + ClearSignatureCache("") + + sig := "validSig1234567890123456789012345678901234567890123456" + CacheSignature(testModelName, "text", sig) + CacheSignature(testModelName, "text-2", sig) + + ClearSignatureCache("session-1") + + if got := GetCachedSignature(testModelName, "text"); got != sig { + t.Error("signature should remain when clearing unknown session") + } +} + func TestClearSignatureCache_AllSessions(t *testing.T) { ClearSignatureCache("") sig := "validSig1234567890123456789012345678901234567890123456" - CacheSignature("test-model", "text1", sig) - CacheSignature("test-model", "text2", sig) + CacheSignature(testModelName, "text", sig) + CacheSignature(testModelName, "text-2", sig) ClearSignatureCache("") - if got := GetCachedSignature("test-model", "text1"); got != "" { - t.Error("text1 should be cleared") + if got := GetCachedSignature(testModelName, "text"); got != "" { + t.Error("text should be cleared") } - if got := GetCachedSignature("test-model", "text2"); got != "" { - t.Error("text2 should be cleared") + if got := GetCachedSignature(testModelName, "text-2"); got != "" { + t.Error("text-2 should be cleared") } } @@ -107,20 +121,19 @@ func TestHasValidSignature(t *testing.T) { signature string expected bool }{ - {"valid long signature", "claude-sonnet-4-5-thinking", "abc123validSignature1234567890123456789012345678901234567890", true}, - {"exactly 50 chars", "claude-sonnet-4-5-thinking", "12345678901234567890123456789012345678901234567890", true}, - {"49 chars - invalid", "claude-sonnet-4-5-thinking", "1234567890123456789012345678901234567890123456789", false}, - {"empty string", "claude-sonnet-4-5-thinking", "", false}, - {"short signature", "claude-sonnet-4-5-thinking", "abc", false}, - {"gemini skip sentinel", "gemini-2.5-pro", "skip_thought_signature_validator", true}, - {"gemini skip sentinel wrong model", "claude-sonnet-4-5-thinking", "skip_thought_signature_validator", false}, + {"valid long signature", testModelName, "abc123validSignature1234567890123456789012345678901234567890", true}, + {"exactly 50 chars", testModelName, "12345678901234567890123456789012345678901234567890", true}, + {"49 chars - invalid", testModelName, "1234567890123456789012345678901234567890123456789", false}, + {"empty string", testModelName, "", false}, + {"short signature", testModelName, "abc", false}, + {"gemini sentinel", "gemini-3-pro-preview", "skip_thought_signature_validator", true}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := HasValidSignature(tt.modelName, tt.signature) if result != tt.expected { - t.Errorf("HasValidSignature(%q, %q) = %v, expected %v", tt.modelName, tt.signature, result, tt.expected) + t.Errorf("HasValidSignature(%q) = %v, expected %v", tt.signature, result, tt.expected) } }) } @@ -135,13 +148,13 @@ func TestCacheSignature_TextHashCollisionResistance(t *testing.T) { sig1 := "signature1_1234567890123456789012345678901234567890123456" sig2 := "signature2_1234567890123456789012345678901234567890123456" - CacheSignature("test-model", text1, sig1) - CacheSignature("test-model", text2, sig2) + CacheSignature(testModelName, text1, sig1) + CacheSignature(testModelName, text2, sig2) - if GetCachedSignature("test-model", text1) != sig1 { + if GetCachedSignature(testModelName, text1) != sig1 { t.Error("text1 signature mismatch") } - if GetCachedSignature("test-model", text2) != sig2 { + if GetCachedSignature(testModelName, text2) != sig2 { t.Error("text2 signature mismatch") } } @@ -152,9 +165,9 @@ func TestCacheSignature_UnicodeText(t *testing.T) { text := "한글 텍스트와 이모지 🎉 그리고 特殊文字" sig := "unicodeSig123456789012345678901234567890123456789012345" - CacheSignature("test-model", text, sig) + CacheSignature(testModelName, text, sig) - if got := GetCachedSignature("test-model", text); got != sig { + if got := GetCachedSignature(testModelName, text); got != sig { t.Errorf("Unicode text signature retrieval failed, got '%s'", got) } } @@ -166,63 +179,32 @@ func TestCacheSignature_Overwrite(t *testing.T) { sig1 := "firstSignature12345678901234567890123456789012345678901" sig2 := "secondSignature1234567890123456789012345678901234567890" - CacheSignature("test-model", text, sig1) - CacheSignature("test-model", text, sig2) // Overwrite + CacheSignature(testModelName, text, sig1) + CacheSignature(testModelName, text, sig2) // Overwrite - if got := GetCachedSignature("test-model", text); got != sig2 { + if got := GetCachedSignature(testModelName, text); got != sig2 { t.Errorf("Expected overwritten signature '%s', got '%s'", sig2, got) } } +// Note: TTL expiration test is tricky to test without mocking time +// We test the logic path exists but actual expiration would require time manipulation func TestCacheSignature_ExpirationLogic(t *testing.T) { ClearSignatureCache("") + // This test verifies the expiration check exists + // In a real scenario, we'd mock time.Now() text := "text" sig := "validSig1234567890123456789012345678901234567890123456" - CacheSignature("test-model", text, sig) + CacheSignature(testModelName, text, sig) // Fresh entry should be retrievable - if got := GetCachedSignature("test-model", text); got != sig { + if got := GetCachedSignature(testModelName, text); got != sig { t.Errorf("Fresh entry should be retrievable, got '%s'", got) } + // We can't easily test actual expiration without time mocking + // but the logic is verified by the implementation _ = time.Now() // Acknowledge we're not testing time passage } - -func TestGetCachedSignature_GeminiFallback(t *testing.T) { - ClearSignatureCache("") - - // For gemini models, missing cache should return skip sentinel - if got := GetCachedSignature("gemini-2.5-pro", "nonexistent"); got != "skip_thought_signature_validator" { - t.Errorf("Expected gemini fallback, got '%s'", got) - } - - // For claude models, missing cache should return empty - if got := GetCachedSignature("claude-sonnet-4-5", "nonexistent"); got != "" { - t.Errorf("Expected empty for claude, got '%s'", got) - } -} - -func TestGetModelGroup(t *testing.T) { - tests := []struct { - modelName string - expected string - }{ - {"gpt-4", "gpt"}, - {"gpt-4-turbo", "gpt"}, - {"claude-3-sonnet", "claude"}, - {"claude-sonnet-4-5-thinking", "claude"}, - {"gemini-2.5-pro", "gemini"}, - {"gemini-1.5-flash", "gemini"}, - {"unknown-model", "unknown-model"}, - } - - for _, tt := range tests { - t.Run(tt.modelName, func(t *testing.T) { - if got := GetModelGroup(tt.modelName); got != tt.expected { - t.Errorf("GetModelGroup(%q) = %q, expected %q", tt.modelName, got, tt.expected) - } - }) - } -} diff --git a/internal/runtime/executor/antigravity_executor.go b/internal/runtime/executor/antigravity_executor.go index d559e179..96255187 100644 --- a/internal/runtime/executor/antigravity_executor.go +++ b/internal/runtime/executor/antigravity_executor.go @@ -1213,7 +1213,17 @@ func (e *AntigravityExecutor) buildRequest(ctx context.Context, auth *cliproxyau // Use the centralized schema cleaner to handle unsupported keywords, // const->enum conversion, and flattening of types/anyOf. strJSON = util.CleanJSONSchemaForAntigravity(strJSON) - + payload = []byte(strJSON) + } else { + strJSON := string(payload) + paths := make([]string, 0) + util.Walk(gjson.Parse(strJSON), "", "parametersJsonSchema", &paths) + for _, p := range paths { + strJSON, _ = util.RenameKey(strJSON, p, p[:len(p)-len("parametersJsonSchema")]+"parameters") + } + // Clean tool schemas for Gemini to remove unsupported JSON Schema keywords + // without adding empty-schema placeholders. + strJSON = util.CleanJSONSchemaForGemini(strJSON) payload = []byte(strJSON) } @@ -1230,6 +1240,12 @@ func (e *AntigravityExecutor) buildRequest(ctx context.Context, auth *cliproxyau } } + if strings.Contains(modelName, "claude") { + payload, _ = sjson.SetBytes(payload, "request.toolConfig.functionCallingConfig.mode", "VALIDATED") + } else { + payload, _ = sjson.DeleteBytes(payload, "request.generationConfig.maxOutputTokens") + } + httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, requestURL.String(), bytes.NewReader(payload)) if errReq != nil { return nil, errReq @@ -1405,26 +1421,10 @@ func geminiToAntigravity(modelName string, payload []byte, projectID string) []b 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.Contains(modelName, "claude") || strings.Contains(modelName, "gemini-3-pro-high") { - 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 - }) + if toolConfig := gjson.Get(template, "toolConfig"); toolConfig.Exists() && !gjson.Get(template, "request.toolConfig").Exists() { + template, _ = sjson.SetRaw(template, "request.toolConfig", toolConfig.Raw) + template, _ = sjson.Delete(template, "toolConfig") } - - if !strings.Contains(modelName, "claude") { - template, _ = sjson.Delete(template, "request.generationConfig.maxOutputTokens") - } - return []byte(template) } @@ -1467,9 +1467,7 @@ func generateProjectID() string { return adj + "-" + noun + "-" + randomPart } - -// Embed returns embeddings for the given request. -// AntigravityExecutor does not support embeddings. +// Embed is not supported by the Antigravity executor. 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/translator/antigravity/claude/antigravity_claude_request_test.go b/internal/translator/antigravity/claude/antigravity_claude_request_test.go index dbf1d4d5..9f40b9fa 100644 --- a/internal/translator/antigravity/claude/antigravity_claude_request_test.go +++ b/internal/translator/antigravity/claude/antigravity_claude_request_test.go @@ -74,13 +74,13 @@ func TestConvertClaudeRequestToAntigravity_RoleMapping(t *testing.T) { } func TestConvertClaudeRequestToAntigravity_ThinkingBlocks(t *testing.T) { + cache.ClearSignatureCache("") + // Valid signature must be at least 50 characters validSignature := "abc123validSignature1234567890123456789012345678901234567890" thinkingText := "Let me think..." - // Pre-cache the signature (simulating a response from the same session) - // The session ID is derived from the first user message hash - // Since there's no user message in this test, we need to add one + // Pre-cache the signature (simulating a previous response for the same thinking text) inputJSON := []byte(`{ "model": "claude-sonnet-4-5-thinking", "messages": [ @@ -117,7 +117,8 @@ func TestConvertClaudeRequestToAntigravity_ThinkingBlocks(t *testing.T) { } func TestConvertClaudeRequestToAntigravity_ThinkingBlockWithoutSignature(t *testing.T) { - cache.ClearSignatureCache("") // Clear any cached signatures from previous tests + cache.ClearSignatureCache("") + // Unsigned thinking blocks should be removed entirely (not converted to text) inputJSON := []byte(`{ "model": "claude-sonnet-4-5-thinking", @@ -239,6 +240,8 @@ func TestConvertClaudeRequestToAntigravity_ToolUse(t *testing.T) { } func TestConvertClaudeRequestToAntigravity_ToolUse_WithSignature(t *testing.T) { + cache.ClearSignatureCache("") + validSignature := "abc123validSignature1234567890123456789012345678901234567890" thinkingText := "Let me think..." @@ -280,6 +283,8 @@ func TestConvertClaudeRequestToAntigravity_ToolUse_WithSignature(t *testing.T) { } func TestConvertClaudeRequestToAntigravity_ReorderThinking(t *testing.T) { + cache.ClearSignatureCache("") + // Case: text block followed by thinking block -> should be reordered to thinking first validSignature := "abc123validSignature1234567890123456789012345678901234567890" thinkingText := "Planning..." @@ -488,6 +493,8 @@ func TestConvertClaudeRequestToAntigravity_TrailingUnsignedThinking_Removed(t *t } func TestConvertClaudeRequestToAntigravity_TrailingSignedThinking_Kept(t *testing.T) { + cache.ClearSignatureCache("") + // Last assistant message ends with signed thinking block - should be kept validSignature := "abc123validSignature1234567890123456789012345678901234567890" thinkingText := "Valid thinking..." diff --git a/internal/translator/antigravity/claude/antigravity_claude_response.go b/internal/translator/antigravity/claude/antigravity_claude_response.go index 57eca78c..3c834f6f 100644 --- a/internal/translator/antigravity/claude/antigravity_claude_response.go +++ b/internal/translator/antigravity/claude/antigravity_claude_response.go @@ -139,7 +139,7 @@ func ConvertAntigravityResponseToClaude(_ context.Context, _ string, originalReq if params.CurrentThinkingText.Len() > 0 { cache.CacheSignature(modelName, params.CurrentThinkingText.String(), thoughtSignature.String()) - // log.Debugf("Cached signature for thinking block (sessionID=%s, textLen=%d)", params.SessionID, params.CurrentThinkingText.Len()) + // log.Debugf("Cached signature for thinking block (textLen=%d)", params.CurrentThinkingText.Len()) params.CurrentThinkingText.Reset() } diff --git a/internal/translator/antigravity/claude/antigravity_claude_response_test.go b/internal/translator/antigravity/claude/antigravity_claude_response_test.go index fa6988c4..c561c557 100644 --- a/internal/translator/antigravity/claude/antigravity_claude_response_test.go +++ b/internal/translator/antigravity/claude/antigravity_claude_response_test.go @@ -12,11 +12,44 @@ import ( // Signature Caching Tests // ============================================================================ +func TestConvertAntigravityResponseToClaude_ParamsInitialized(t *testing.T) { + cache.ClearSignatureCache("") + + // Request with user message - should initialize params + requestJSON := []byte(`{ + "messages": [ + {"role": "user", "content": [{"type": "text", "text": "Hello world"}]} + ] + }`) + + // First response chunk with thinking + responseJSON := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "Let me think...", "thought": true}] + } + }] + } + }`) + + var param any + ctx := context.Background() + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, responseJSON, ¶m) + + params := param.(*Params) + if !params.HasFirstResponse { + t.Error("HasFirstResponse should be set after first chunk") + } + if params.CurrentThinkingText.Len() == 0 { + t.Error("Thinking text should be accumulated") + } +} + func TestConvertAntigravityResponseToClaude_ThinkingTextAccumulated(t *testing.T) { cache.ClearSignatureCache("") requestJSON := []byte(`{ - "model": "claude-sonnet-4-5-thinking", "messages": [{"role": "user", "content": [{"type": "text", "text": "Test"}]}] }`) @@ -36,7 +69,7 @@ func TestConvertAntigravityResponseToClaude_ThinkingTextAccumulated(t *testing.T "response": { "candidates": [{ "content": { - "parts": [{"text": " Second part of thinking.", "thought": true}] + "parts": [{"text": " Second part of thinking...", "thought": true}] } }] } @@ -45,12 +78,17 @@ func TestConvertAntigravityResponseToClaude_ThinkingTextAccumulated(t *testing.T var param any ctx := context.Background() - // Process both chunks + // Process first chunk - starts new thinking block ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, chunk1, ¶m) + params := param.(*Params) + + if params.CurrentThinkingText.Len() == 0 { + t.Error("Thinking text should be accumulated after first chunk") + } + + // Process second chunk - continues thinking block ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, chunk2, ¶m) - // Verify thinking text was accumulated - params := param.(*Params) text := params.CurrentThinkingText.String() if !strings.Contains(text, "First part") || !strings.Contains(text, "Second part") { t.Errorf("Thinking text should accumulate both parts, got: %s", text) @@ -114,3 +152,95 @@ func TestConvertAntigravityResponseToClaude_SignatureCached(t *testing.T) { t.Error("Thinking text should be reset after signature is cached") } } + +func TestConvertAntigravityResponseToClaude_MultipleThinkingBlocks(t *testing.T) { + cache.ClearSignatureCache("") + + requestJSON := []byte(`{ + "model": "claude-sonnet-4-5-thinking", + "messages": [{"role": "user", "content": [{"type": "text", "text": "Multi block test"}]}] + }`) + + validSig1 := "signature1_12345678901234567890123456789012345678901234567" + validSig2 := "signature2_12345678901234567890123456789012345678901234567" + + // First thinking block with signature + block1Thinking := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "First thinking block", "thought": true}] + } + }] + } + }`) + block1Sig := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "", "thought": true, "thoughtSignature": "` + validSig1 + `"}] + } + }] + } + }`) + + // Text content (breaks thinking) + textBlock := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "Regular text output"}] + } + }] + } + }`) + + // Second thinking block with signature + block2Thinking := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "Second thinking block", "thought": true}] + } + }] + } + }`) + block2Sig := []byte(`{ + "response": { + "candidates": [{ + "content": { + "parts": [{"text": "", "thought": true, "thoughtSignature": "` + validSig2 + `"}] + } + }] + } + }`) + + var param any + ctx := context.Background() + + // Process first thinking block + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, block1Thinking, ¶m) + params := param.(*Params) + firstThinkingText := params.CurrentThinkingText.String() + + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, block1Sig, ¶m) + + // Verify first signature cached + if cache.GetCachedSignature("claude-sonnet-4-5-thinking", firstThinkingText) != validSig1 { + t.Error("First thinking block signature should be cached") + } + + // Process text (transitions out of thinking) + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, textBlock, ¶m) + + // Process second thinking block + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, block2Thinking, ¶m) + secondThinkingText := params.CurrentThinkingText.String() + + ConvertAntigravityResponseToClaude(ctx, "claude-sonnet-4-5-thinking", requestJSON, requestJSON, block2Sig, ¶m) + + // Verify second signature cached + if cache.GetCachedSignature("claude-sonnet-4-5-thinking", secondThinkingText) != validSig2 { + t.Error("Second thinking block signature should be cached") + } +} diff --git a/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go b/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go index ab0d4339..8867a30e 100644 --- a/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go +++ b/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go @@ -62,46 +62,6 @@ func TestConvertGeminiRequestToAntigravity_AddSkipSentinelToFunctionCall(t *test } } -func TestConvertGeminiRequestToAntigravity_AnnotateThinkingBlocks(t *testing.T) { - // Thinking blocks should be kept and annotated with skip_thought_signature_validator for Gemini - validSignature := "abc123validSignature1234567890123456789012345678901234567890" - inputJSON := []byte(fmt.Sprintf(`{ - "model": "gemini-3-pro-preview", - "contents": [ - { - "role": "model", - "parts": [ - {"thought": true, "text": "Thinking...", "thoughtSignature": "%s"}, - {"text": "Here is my response"} - ] - } - ] - }`, validSignature)) - - output := ConvertGeminiRequestToAntigravity("gemini-3-pro-preview", inputJSON, false) - outputStr := string(output) - - // Check that thinking block is kept and annotated - parts := gjson.Get(outputStr, "request.contents.0.parts").Array() - if len(parts) != 2 { - t.Fatalf("Expected 2 parts (thinking kept and annotated), got %d", len(parts)) - } - - // First part should be thinking block with skip sentinel - if !parts[0].Get("thought").Bool() { - t.Error("First part should be thinking block") - } - expectedSig := "skip_thought_signature_validator" - if parts[0].Get("thoughtSignature").String() != expectedSig { - t.Errorf("Expected thoughtSignature '%s', got '%s'", expectedSig, parts[0].Get("thoughtSignature").String()) - } - - // Second part should be text - if parts[1].Get("text").String() != "Here is my response" { - t.Errorf("Expected text 'Here is my response', got '%s'", parts[1].Get("text").String()) - } -} - func TestConvertGeminiRequestToAntigravity_ParallelFunctionCalls(t *testing.T) { // Multiple functionCalls should all get skip_thought_signature_validator inputJSON := []byte(`{ diff --git a/internal/util/gemini_schema.go b/internal/util/gemini_schema.go index 1aa787a2..867dd4fa 100644 --- a/internal/util/gemini_schema.go +++ b/internal/util/gemini_schema.go @@ -12,10 +12,23 @@ import ( var gjsonPathKeyReplacer = strings.NewReplacer(".", "\\.", "*", "\\*", "?", "\\?") +const placeholderReasonDescription = "Brief explanation of why you are calling this tool" + // CleanJSONSchemaForAntigravity transforms a JSON schema to be compatible with Antigravity API. // It handles unsupported keywords, type flattening, and schema simplification while preserving // semantic information as description hints. func CleanJSONSchemaForAntigravity(jsonStr string) string { + return cleanJSONSchema(jsonStr, true) +} + +// CleanJSONSchemaForGemini transforms a JSON schema to be compatible with Gemini tool calling. +// It removes unsupported keywords and simplifies schemas, without adding empty-schema placeholders. +func CleanJSONSchemaForGemini(jsonStr string) string { + return cleanJSONSchema(jsonStr, false) +} + +// cleanJSONSchema performs the core cleaning operations on the JSON schema. +func cleanJSONSchema(jsonStr string, addPlaceholder bool) string { // Phase 1: Convert and add hints jsonStr = convertRefsToHints(jsonStr) jsonStr = convertConstToEnum(jsonStr) @@ -31,10 +44,94 @@ func CleanJSONSchemaForAntigravity(jsonStr string) string { // Phase 3: Cleanup jsonStr = removeUnsupportedKeywords(jsonStr) + if !addPlaceholder { + // Gemini schema cleanup: remove nullable/title and placeholder-only fields. + jsonStr = removeKeywords(jsonStr, []string{"nullable", "title"}) + jsonStr = removePlaceholderFields(jsonStr) + } jsonStr = cleanupRequiredFields(jsonStr) - // Phase 4: Add placeholder for empty object schemas (Claude VALIDATED mode requirement) - jsonStr = addEmptySchemaPlaceholder(jsonStr) + if addPlaceholder { + jsonStr = addEmptySchemaPlaceholder(jsonStr) + } + + return jsonStr +} + +// removeKeywords removes all occurrences of specified keywords from the JSON schema. +func removeKeywords(jsonStr string, keywords []string) string { + for _, key := range keywords { + for _, p := range findPaths(jsonStr, key) { + if isPropertyDefinition(trimSuffix(p, "."+key)) { + continue + } + jsonStr, _ = sjson.Delete(jsonStr, p) + } + } + return jsonStr +} + +// removePlaceholderFields removes placeholder-only properties ("_" and "reason") and their required entries. +func removePlaceholderFields(jsonStr string) string { + // Remove "_" placeholder properties. + paths := findPaths(jsonStr, "_") + sortByDepth(paths) + for _, p := range paths { + if !strings.HasSuffix(p, ".properties._") { + continue + } + jsonStr, _ = sjson.Delete(jsonStr, p) + parentPath := trimSuffix(p, ".properties._") + reqPath := joinPath(parentPath, "required") + req := gjson.Get(jsonStr, reqPath) + if req.IsArray() { + var filtered []string + for _, r := range req.Array() { + if r.String() != "_" { + filtered = append(filtered, r.String()) + } + } + if len(filtered) == 0 { + jsonStr, _ = sjson.Delete(jsonStr, reqPath) + } else { + jsonStr, _ = sjson.Set(jsonStr, reqPath, filtered) + } + } + } + + // Remove placeholder-only "reason" objects. + reasonPaths := findPaths(jsonStr, "reason") + sortByDepth(reasonPaths) + for _, p := range reasonPaths { + if !strings.HasSuffix(p, ".properties.reason") { + continue + } + parentPath := trimSuffix(p, ".properties.reason") + props := gjson.Get(jsonStr, joinPath(parentPath, "properties")) + if !props.IsObject() || len(props.Map()) != 1 { + continue + } + desc := gjson.Get(jsonStr, p+".description").String() + if desc != placeholderReasonDescription { + continue + } + jsonStr, _ = sjson.Delete(jsonStr, p) + reqPath := joinPath(parentPath, "required") + req := gjson.Get(jsonStr, reqPath) + if req.IsArray() { + var filtered []string + for _, r := range req.Array() { + if r.String() != "reason" { + filtered = append(filtered, r.String()) + } + } + if len(filtered) == 0 { + jsonStr, _ = sjson.Delete(jsonStr, reqPath) + } else { + jsonStr, _ = sjson.Set(jsonStr, reqPath, filtered) + } + } + } return jsonStr } @@ -409,7 +506,7 @@ func addEmptySchemaPlaceholder(jsonStr string) string { // Add placeholder "reason" property reasonPath := joinPath(propsPath, "reason") jsonStr, _ = sjson.Set(jsonStr, reasonPath+".type", "string") - jsonStr, _ = sjson.Set(jsonStr, reasonPath+".description", "Brief explanation of why you are calling this tool") + jsonStr, _ = sjson.Set(jsonStr, reasonPath+".description", placeholderReasonDescription) // Add to required array jsonStr, _ = sjson.Set(jsonStr, reqPath, []string{"reason"}) @@ -418,6 +515,11 @@ func addEmptySchemaPlaceholder(jsonStr string) string { // If schema has properties but none are required, add a minimal placeholder. if propsVal.IsObject() && !hasRequiredProperties { + // DO NOT add placeholder if it's a top-level schema (parentPath is empty) + // or if we've already added a placeholder reason above. + if parentPath == "" { + continue + } placeholderPath := joinPath(propsPath, "_") if !gjson.Get(jsonStr, placeholderPath).Exists() { jsonStr, _ = sjson.Set(jsonStr, placeholderPath+".type", "boolean") diff --git a/internal/util/gemini_schema_test.go b/internal/util/gemini_schema_test.go index 8b7aa936..ca77225e 100644 --- a/internal/util/gemini_schema_test.go +++ b/internal/util/gemini_schema_test.go @@ -23,13 +23,11 @@ func TestCleanJSONSchemaForAntigravity_ConstToEnum(t *testing.T) { expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "kind": { "type": "string", "enum": ["InsightVizNode"] } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -125,7 +123,6 @@ func TestCleanJSONSchemaForAntigravity_AnyOfFlattening_SmartSelection(t *testing expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "query": { "type": "object", "description": "Accepts: null | object", @@ -135,8 +132,7 @@ func TestCleanJSONSchemaForAntigravity_AnyOfFlattening_SmartSelection(t *testing }, "required": ["_"] } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -159,13 +155,11 @@ func TestCleanJSONSchemaForAntigravity_OneOfFlattening(t *testing.T) { expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "config": { "type": "string", "description": "Accepts: string | integer" } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -221,11 +215,9 @@ func TestCleanJSONSchemaForAntigravity_RefHandling(t *testing.T) { }` // After $ref is converted to placeholder object, empty schema placeholder is also added - // Root object gets "_" placeholder since it has properties but no required expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "customer": { "type": "object", "description": "See: User", @@ -237,8 +229,7 @@ func TestCleanJSONSchemaForAntigravity_RefHandling(t *testing.T) { }, "required": ["reason"] } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -265,11 +256,9 @@ func TestCleanJSONSchemaForAntigravity_RefHandling_DescriptionEscaping(t *testin }` // After $ref is converted, empty schema placeholder is also added - // Root object gets "_" placeholder since it has properties but no required expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "customer": { "type": "object", "description": "He said \"hi\"\\nsecond line (See: User)", @@ -281,8 +270,7 @@ func TestCleanJSONSchemaForAntigravity_RefHandling_DescriptionEscaping(t *testin }, "required": ["reason"] } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -576,17 +564,14 @@ func TestCleanJSONSchemaForAntigravity_AnyOfFlattening_PreservesDescription(t *t } }` - // Root object gets "_" placeholder since it has properties but no required expected := `{ "type": "object", "properties": { - "_": { "type": "boolean" }, "config": { "type": "string", "description": "Parent desc (Child desc) (Accepts: string | integer)" } - }, - "required": ["_"] + } }` result := CleanJSONSchemaForAntigravity(input) @@ -631,82 +616,6 @@ func TestCleanJSONSchemaForAntigravity_MultipleNonNullTypes(t *testing.T) { } } -func TestCleanJSONSchemaForAntigravity_PropertyNamesRemoval(t *testing.T) { - // propertyNames is used to validate object property names (e.g., must match a pattern) - // Gemini doesn't support this keyword and will reject requests containing it - input := `{ - "type": "object", - "properties": { - "metadata": { - "type": "object", - "propertyNames": { - "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" - }, - "additionalProperties": { - "type": "string" - } - } - } - }` - - // After cleanup, empty nested object gets placeholder property (Claude VALIDATED mode requirement) - // Root object gets "_" placeholder since it has properties but no required - expected := `{ - "type": "object", - "properties": { - "_": { "type": "boolean" }, - "metadata": { - "type": "object", - "properties": { - "reason": { - "type": "string", - "description": "Brief explanation of why you are calling this tool" - } - }, - "required": ["reason"] - } - }, - "required": ["_"] - }` - - result := CleanJSONSchemaForAntigravity(input) - compareJSON(t, expected, result) - - // Verify propertyNames is completely removed - if strings.Contains(result, "propertyNames") { - t.Errorf("propertyNames keyword should be removed, got: %s", result) - } -} - -func TestCleanJSONSchemaForAntigravity_PropertyNamesRemoval_Nested(t *testing.T) { - // Test deeply nested propertyNames (as seen in real Claude tool schemas) - input := `{ - "type": "object", - "properties": { - "items": { - "type": "array", - "items": { - "type": "object", - "properties": { - "config": { - "type": "object", - "propertyNames": { - "type": "string" - } - } - } - } - } - } - }` - - result := CleanJSONSchemaForAntigravity(input) - - if strings.Contains(result, "propertyNames") { - t.Errorf("Nested propertyNames should be removed, got: %s", result) - } -} - func compareJSON(t *testing.T, expectedJSON, actualJSON string) { var expMap, actMap map[string]interface{} errExp := json.Unmarshal([]byte(expectedJSON), &expMap)