diff --git a/internal/registry/model_definitions_static_data.go b/internal/registry/model_definitions_static_data.go index 18a1a3a1..8ed8356e 100644 --- a/internal/registry/model_definitions_static_data.go +++ b/internal/registry/model_definitions_static_data.go @@ -916,19 +916,12 @@ func GetIFlowModels() []*ModelInfo { Created int64 Thinking *ThinkingSupport }{ - {ID: "tstars2.0", DisplayName: "TStars-2.0", Description: "iFlow TStars-2.0 multimodal assistant", Created: 1746489600}, {ID: "qwen3-coder-plus", DisplayName: "Qwen3-Coder-Plus", Description: "Qwen3 Coder Plus code generation", Created: 1753228800}, {ID: "qwen3-max", DisplayName: "Qwen3-Max", Description: "Qwen3 flagship model", Created: 1758672000}, {ID: "qwen3-vl-plus", DisplayName: "Qwen3-VL-Plus", Description: "Qwen3 multimodal vision-language", Created: 1758672000}, {ID: "qwen3-max-preview", DisplayName: "Qwen3-Max-Preview", Description: "Qwen3 Max preview build", Created: 1757030400, Thinking: iFlowThinkingSupport}, - {ID: "kimi-k2-0905", DisplayName: "Kimi-K2-Instruct-0905", Description: "Moonshot Kimi K2 instruct 0905", Created: 1757030400}, {ID: "glm-4.6", DisplayName: "GLM-4.6", Description: "Zhipu GLM 4.6 general model", Created: 1759190400, Thinking: iFlowThinkingSupport}, - {ID: "glm-4.7", DisplayName: "GLM-4.7", Description: "Zhipu GLM 4.7 general model", Created: 1766448000, Thinking: iFlowThinkingSupport}, - {ID: "glm-5", DisplayName: "GLM-5", Description: "Zhipu GLM 5 general model", Created: 1770768000, Thinking: iFlowThinkingSupport}, {ID: "kimi-k2", DisplayName: "Kimi-K2", Description: "Moonshot Kimi K2 general model", Created: 1752192000}, - {ID: "kimi-k2-thinking", DisplayName: "Kimi-K2-Thinking", Description: "Moonshot Kimi K2 thinking model", Created: 1762387200}, - {ID: "deepseek-v3.2-chat", DisplayName: "DeepSeek-V3.2", Description: "DeepSeek V3.2 Chat", Created: 1764576000}, - {ID: "deepseek-v3.2-reasoner", DisplayName: "DeepSeek-V3.2", Description: "DeepSeek V3.2 Reasoner", Created: 1764576000}, {ID: "deepseek-v3.2", DisplayName: "DeepSeek-V3.2-Exp", Description: "DeepSeek V3.2 experimental", Created: 1759104000, Thinking: iFlowThinkingSupport}, {ID: "deepseek-v3.1", DisplayName: "DeepSeek-V3.1-Terminus", Description: "DeepSeek V3.1 Terminus", Created: 1756339200, Thinking: iFlowThinkingSupport}, {ID: "deepseek-r1", DisplayName: "DeepSeek-R1", Description: "DeepSeek reasoning model R1", Created: 1737331200}, @@ -937,11 +930,7 @@ func GetIFlowModels() []*ModelInfo { {ID: "qwen3-235b-a22b-thinking-2507", DisplayName: "Qwen3-235B-A22B-Thinking", Description: "Qwen3 235B A22B Thinking (2507)", Created: 1753401600}, {ID: "qwen3-235b-a22b-instruct", DisplayName: "Qwen3-235B-A22B-Instruct", Description: "Qwen3 235B A22B Instruct", Created: 1753401600}, {ID: "qwen3-235b", DisplayName: "Qwen3-235B-A22B", Description: "Qwen3 235B A22B", Created: 1753401600}, - {ID: "minimax-m2", DisplayName: "MiniMax-M2", Description: "MiniMax M2", Created: 1758672000, Thinking: iFlowThinkingSupport}, - {ID: "minimax-m2.1", DisplayName: "MiniMax-M2.1", Description: "MiniMax M2.1", Created: 1766448000, Thinking: iFlowThinkingSupport}, - {ID: "minimax-m2.5", DisplayName: "MiniMax-M2.5", Description: "MiniMax M2.5", Created: 1770825600, Thinking: iFlowThinkingSupport}, {ID: "iflow-rome-30ba3b", DisplayName: "iFlow-ROME", Description: "iFlow Rome 30BA3B model", Created: 1736899200}, - {ID: "kimi-k2.5", DisplayName: "Kimi-K2.5", Description: "Moonshot Kimi K2.5", Created: 1769443200, Thinking: iFlowThinkingSupport}, } models := make([]*ModelInfo, 0, len(entries)) for _, entry := range entries { diff --git a/internal/runtime/executor/antigravity_executor.go b/internal/runtime/executor/antigravity_executor.go index 652cb472..04b9764d 100644 --- a/internal/runtime/executor/antigravity_executor.go +++ b/internal/runtime/executor/antigravity_executor.go @@ -54,8 +54,78 @@ const ( var ( randSource = rand.New(rand.NewSource(time.Now().UnixNano())) randSourceMutex sync.Mutex + // antigravityPrimaryModelsCache keeps the latest non-empty model list fetched + // from any antigravity auth. Empty fetches never overwrite this cache. + antigravityPrimaryModelsCache struct { + mu sync.RWMutex + models []*registry.ModelInfo + } ) +func cloneAntigravityModels(models []*registry.ModelInfo) []*registry.ModelInfo { + if len(models) == 0 { + return nil + } + out := make([]*registry.ModelInfo, 0, len(models)) + for _, model := range models { + if model == nil || strings.TrimSpace(model.ID) == "" { + continue + } + out = append(out, cloneAntigravityModelInfo(model)) + } + if len(out) == 0 { + return nil + } + return out +} + +func cloneAntigravityModelInfo(model *registry.ModelInfo) *registry.ModelInfo { + if model == nil { + return nil + } + clone := *model + if len(model.SupportedGenerationMethods) > 0 { + clone.SupportedGenerationMethods = append([]string(nil), model.SupportedGenerationMethods...) + } + if len(model.SupportedParameters) > 0 { + clone.SupportedParameters = append([]string(nil), model.SupportedParameters...) + } + if model.Thinking != nil { + thinkingClone := *model.Thinking + if len(model.Thinking.Levels) > 0 { + thinkingClone.Levels = append([]string(nil), model.Thinking.Levels...) + } + clone.Thinking = &thinkingClone + } + return &clone +} + +func storeAntigravityPrimaryModels(models []*registry.ModelInfo) bool { + cloned := cloneAntigravityModels(models) + if len(cloned) == 0 { + return false + } + antigravityPrimaryModelsCache.mu.Lock() + antigravityPrimaryModelsCache.models = cloned + antigravityPrimaryModelsCache.mu.Unlock() + return true +} + +func loadAntigravityPrimaryModels() []*registry.ModelInfo { + antigravityPrimaryModelsCache.mu.RLock() + cloned := cloneAntigravityModels(antigravityPrimaryModelsCache.models) + antigravityPrimaryModelsCache.mu.RUnlock() + return cloned +} + +func fallbackAntigravityPrimaryModels() []*registry.ModelInfo { + models := loadAntigravityPrimaryModels() + if len(models) > 0 { + log.Debugf("antigravity executor: using cached primary model list (%d models)", len(models)) + } + return models +} + // AntigravityExecutor proxies requests to the antigravity upstream. type AntigravityExecutor struct { cfg *config.Config @@ -1006,14 +1076,9 @@ func (e *AntigravityExecutor) CountTokens(ctx context.Context, auth *cliproxyaut 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 { - log.Warnf("antigravity executor: fetch models failed for %s: token error: %v", auth.ID, errToken) - return nil - } - if token == "" { - log.Warnf("antigravity executor: fetch models failed for %s: got empty token", auth.ID) - return nil - } + if errToken != nil || token == "" { + return fallbackAntigravityPrimaryModels() + } if updatedAuth != nil { auth = updatedAuth } @@ -1025,8 +1090,7 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c modelsURL := baseURL + antigravityModelsPath httpReq, errReq := http.NewRequestWithContext(ctx, http.MethodPost, modelsURL, bytes.NewReader([]byte(`{}`))) if errReq != nil { - log.Warnf("antigravity executor: fetch models failed for %s: create request error: %v", auth.ID, errReq) - return nil + return fallbackAntigravityPrimaryModels() } httpReq.Header.Set("Content-Type", "application/json") httpReq.Header.Set("Authorization", "Bearer "+token) @@ -1038,15 +1102,13 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c httpResp, errDo := httpClient.Do(httpReq) if errDo != nil { if errors.Is(errDo, context.Canceled) || errors.Is(errDo, context.DeadlineExceeded) { - log.Warnf("antigravity executor: fetch models failed for %s: context canceled: %v", auth.ID, errDo) - return nil + return fallbackAntigravityPrimaryModels() } 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 } - log.Warnf("antigravity executor: fetch models failed for %s: request error: %v", auth.ID, errDo) - return nil + return fallbackAntigravityPrimaryModels() } bodyBytes, errRead := io.ReadAll(httpResp.Body) @@ -1058,22 +1120,27 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c log.Debugf("antigravity executor: models read error on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) continue } - log.Warnf("antigravity executor: fetch models failed for %s: read body error: %v", auth.ID, errRead) - return nil + return fallbackAntigravityPrimaryModels() } 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 } - log.Warnf("antigravity executor: fetch models failed for %s: unexpected status %d, body: %s", auth.ID, httpResp.StatusCode, string(bodyBytes)) - return nil + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: models request failed with status %d on base url %s, retrying with fallback base url: %s", httpResp.StatusCode, baseURL, baseURLs[idx+1]) + continue + } + return fallbackAntigravityPrimaryModels() } result := gjson.GetBytes(bodyBytes, "models") if !result.Exists() { - log.Warnf("antigravity executor: fetch models failed for %s: no models field in response, body: %s", auth.ID, string(bodyBytes)) - return nil + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: models field missing on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + return fallbackAntigravityPrimaryModels() } now := time.Now().Unix() @@ -1118,9 +1185,18 @@ func FetchAntigravityModels(ctx context.Context, auth *cliproxyauth.Auth, cfg *c } models = append(models, modelInfo) } + if len(models) == 0 { + if idx+1 < len(baseURLs) { + log.Debugf("antigravity executor: empty models list on base url %s, retrying with fallback base url: %s", baseURL, baseURLs[idx+1]) + continue + } + log.Debug("antigravity executor: fetched empty model list; retaining cached primary model list") + return fallbackAntigravityPrimaryModels() + } + storeAntigravityPrimaryModels(models) return models } - return nil + return fallbackAntigravityPrimaryModels() } func (e *AntigravityExecutor) ensureAccessToken(ctx context.Context, auth *cliproxyauth.Auth) (string, *cliproxyauth.Auth, error) { diff --git a/internal/runtime/executor/antigravity_executor_models_cache_test.go b/internal/runtime/executor/antigravity_executor_models_cache_test.go new file mode 100644 index 00000000..be49a7c1 --- /dev/null +++ b/internal/runtime/executor/antigravity_executor_models_cache_test.go @@ -0,0 +1,90 @@ +package executor + +import ( + "testing" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" +) + +func resetAntigravityPrimaryModelsCacheForTest() { + antigravityPrimaryModelsCache.mu.Lock() + antigravityPrimaryModelsCache.models = nil + antigravityPrimaryModelsCache.mu.Unlock() +} + +func TestStoreAntigravityPrimaryModels_EmptyDoesNotOverwrite(t *testing.T) { + resetAntigravityPrimaryModelsCacheForTest() + t.Cleanup(resetAntigravityPrimaryModelsCacheForTest) + + seed := []*registry.ModelInfo{ + {ID: "claude-sonnet-4-5"}, + {ID: "gemini-2.5-pro"}, + } + if updated := storeAntigravityPrimaryModels(seed); !updated { + t.Fatal("expected non-empty model list to update primary cache") + } + + if updated := storeAntigravityPrimaryModels(nil); updated { + t.Fatal("expected nil model list not to overwrite primary cache") + } + if updated := storeAntigravityPrimaryModels([]*registry.ModelInfo{}); updated { + t.Fatal("expected empty model list not to overwrite primary cache") + } + + got := loadAntigravityPrimaryModels() + if len(got) != 2 { + t.Fatalf("expected cached model count 2, got %d", len(got)) + } + if got[0].ID != "claude-sonnet-4-5" || got[1].ID != "gemini-2.5-pro" { + t.Fatalf("unexpected cached model ids: %q, %q", got[0].ID, got[1].ID) + } +} + +func TestLoadAntigravityPrimaryModels_ReturnsClone(t *testing.T) { + resetAntigravityPrimaryModelsCacheForTest() + t.Cleanup(resetAntigravityPrimaryModelsCacheForTest) + + if updated := storeAntigravityPrimaryModels([]*registry.ModelInfo{{ + ID: "gpt-5", + DisplayName: "GPT-5", + SupportedGenerationMethods: []string{"generateContent"}, + SupportedParameters: []string{"temperature"}, + Thinking: ®istry.ThinkingSupport{ + Levels: []string{"high"}, + }, + }}); !updated { + t.Fatal("expected model cache update") + } + + got := loadAntigravityPrimaryModels() + if len(got) != 1 { + t.Fatalf("expected one cached model, got %d", len(got)) + } + got[0].ID = "mutated-id" + if len(got[0].SupportedGenerationMethods) > 0 { + got[0].SupportedGenerationMethods[0] = "mutated-method" + } + if len(got[0].SupportedParameters) > 0 { + got[0].SupportedParameters[0] = "mutated-parameter" + } + if got[0].Thinking != nil && len(got[0].Thinking.Levels) > 0 { + got[0].Thinking.Levels[0] = "mutated-level" + } + + again := loadAntigravityPrimaryModels() + if len(again) != 1 { + t.Fatalf("expected one cached model after mutation, got %d", len(again)) + } + if again[0].ID != "gpt-5" { + t.Fatalf("expected cached model id to remain %q, got %q", "gpt-5", again[0].ID) + } + if len(again[0].SupportedGenerationMethods) == 0 || again[0].SupportedGenerationMethods[0] != "generateContent" { + t.Fatalf("expected cached generation methods to be unmutated, got %v", again[0].SupportedGenerationMethods) + } + if len(again[0].SupportedParameters) == 0 || again[0].SupportedParameters[0] != "temperature" { + t.Fatalf("expected cached supported parameters to be unmutated, got %v", again[0].SupportedParameters) + } + if again[0].Thinking == nil || len(again[0].Thinking.Levels) == 0 || again[0].Thinking.Levels[0] != "high" { + t.Fatalf("expected cached model thinking levels to be unmutated, got %v", again[0].Thinking) + } +} diff --git a/internal/translator/antigravity/claude/antigravity_claude_request.go b/internal/translator/antigravity/claude/antigravity_claude_request.go index 448aa976..b634436d 100644 --- a/internal/translator/antigravity/claude/antigravity_claude_request.go +++ b/internal/translator/antigravity/claude/antigravity_claude_request.go @@ -223,14 +223,65 @@ func ConvertClaudeRequestToAntigravity(modelName string, inputRawJSON []byte, _ functionResponseJSON, _ = sjson.Set(functionResponseJSON, "response.result", responseData) } else if functionResponseResult.IsArray() { frResults := functionResponseResult.Array() - if len(frResults) == 1 { - functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", frResults[0].Raw) + nonImageCount := 0 + lastNonImageRaw := "" + filteredJSON := "[]" + imagePartsJSON := "[]" + for _, fr := range frResults { + if fr.Get("type").String() == "image" && fr.Get("source.type").String() == "base64" { + inlineDataJSON := `{}` + if mimeType := fr.Get("source.media_type").String(); mimeType != "" { + inlineDataJSON, _ = sjson.Set(inlineDataJSON, "mimeType", mimeType) + } + if data := fr.Get("source.data").String(); data != "" { + inlineDataJSON, _ = sjson.Set(inlineDataJSON, "data", data) + } + + imagePartJSON := `{}` + imagePartJSON, _ = sjson.SetRaw(imagePartJSON, "inlineData", inlineDataJSON) + imagePartsJSON, _ = sjson.SetRaw(imagePartsJSON, "-1", imagePartJSON) + continue + } + + nonImageCount++ + lastNonImageRaw = fr.Raw + filteredJSON, _ = sjson.SetRaw(filteredJSON, "-1", fr.Raw) + } + + if nonImageCount == 1 { + functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", lastNonImageRaw) + } else if nonImageCount > 1 { + functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", filteredJSON) } else { - functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", functionResponseResult.Raw) + functionResponseJSON, _ = sjson.Set(functionResponseJSON, "response.result", "") + } + + // Place image data inside functionResponse.parts as inlineData + // instead of as sibling parts in the outer content, to avoid + // base64 data bloating the text context. + if gjson.Get(imagePartsJSON, "#").Int() > 0 { + functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "parts", imagePartsJSON) } } else if functionResponseResult.IsObject() { - functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", functionResponseResult.Raw) + if functionResponseResult.Get("type").String() == "image" && functionResponseResult.Get("source.type").String() == "base64" { + inlineDataJSON := `{}` + if mimeType := functionResponseResult.Get("source.media_type").String(); mimeType != "" { + inlineDataJSON, _ = sjson.Set(inlineDataJSON, "mimeType", mimeType) + } + if data := functionResponseResult.Get("source.data").String(); data != "" { + inlineDataJSON, _ = sjson.Set(inlineDataJSON, "data", data) + } + + imagePartJSON := `{}` + imagePartJSON, _ = sjson.SetRaw(imagePartJSON, "inlineData", inlineDataJSON) + imagePartsJSON := "[]" + imagePartsJSON, _ = sjson.SetRaw(imagePartsJSON, "-1", imagePartJSON) + functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "parts", imagePartsJSON) + functionResponseJSON, _ = sjson.Set(functionResponseJSON, "response.result", "") + } else { + functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", functionResponseResult.Raw) + } } else if functionResponseResult.Raw != "" { functionResponseJSON, _ = sjson.SetRaw(functionResponseJSON, "response.result", functionResponseResult.Raw) } else { @@ -248,7 +299,7 @@ func ConvertClaudeRequestToAntigravity(modelName string, inputRawJSON []byte, _ if sourceResult.Get("type").String() == "base64" { inlineDataJSON := `{}` if mimeType := sourceResult.Get("media_type").String(); mimeType != "" { - inlineDataJSON, _ = sjson.Set(inlineDataJSON, "mime_type", mimeType) + inlineDataJSON, _ = sjson.Set(inlineDataJSON, "mimeType", mimeType) } if data := sourceResult.Get("data").String(); data != "" { inlineDataJSON, _ = sjson.Set(inlineDataJSON, "data", data) diff --git a/internal/translator/antigravity/claude/antigravity_claude_request_test.go b/internal/translator/antigravity/claude/antigravity_claude_request_test.go index c28a14ec..865db668 100644 --- a/internal/translator/antigravity/claude/antigravity_claude_request_test.go +++ b/internal/translator/antigravity/claude/antigravity_claude_request_test.go @@ -413,8 +413,8 @@ func TestConvertClaudeRequestToAntigravity_ImageContent(t *testing.T) { if !inlineData.Exists() { t.Error("inlineData should exist") } - if inlineData.Get("mime_type").String() != "image/png" { - t.Error("mime_type mismatch") + if inlineData.Get("mimeType").String() != "image/png" { + t.Error("mimeType mismatch") } if !strings.Contains(inlineData.Get("data").String(), "iVBORw0KGgo") { t.Error("data mismatch") @@ -740,6 +740,429 @@ func TestConvertClaudeRequestToAntigravity_ToolResultNullContent(t *testing.T) { } } +func TestConvertClaudeRequestToAntigravity_ToolResultWithImage(t *testing.T) { + // tool_result with array content containing text + image should place + // image data inside functionResponse.parts as inlineData, not as a + // sibling part in the outer content (to avoid base64 context bloat). + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "Read-123-456", + "content": [ + { + "type": "text", + "text": "File content here" + }, + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": "iVBORw0KGgoAAAANSUhEUg==" + } + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + // Image should be inside functionResponse.parts, not as outer sibling part + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // Text content should be in response.result + resultText := funcResp.Get("response.result.text").String() + if resultText != "File content here" { + t.Errorf("Expected response.result.text = 'File content here', got '%s'", resultText) + } + + // Image should be in functionResponse.parts[0].inlineData + inlineData := funcResp.Get("parts.0.inlineData") + if !inlineData.Exists() { + t.Fatal("functionResponse.parts[0].inlineData should exist") + } + if inlineData.Get("mimeType").String() != "image/png" { + t.Errorf("Expected mimeType 'image/png', got '%s'", inlineData.Get("mimeType").String()) + } + if !strings.Contains(inlineData.Get("data").String(), "iVBORw0KGgo") { + t.Error("data mismatch") + } + + // Image should NOT be in outer parts (only functionResponse part should exist) + outerParts := gjson.Get(outputStr, "request.contents.0.parts") + if outerParts.IsArray() && len(outerParts.Array()) > 1 { + t.Errorf("Expected only 1 outer part (functionResponse), got %d", len(outerParts.Array())) + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultWithSingleImage(t *testing.T) { + // tool_result with single image object as content should place + // image data inside functionResponse.parts, not as outer sibling part. + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "Read-789-012", + "content": { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/jpeg", + "data": "/9j/4AAQSkZJRgABAQ==" + } + } + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // response.result should be empty (image only) + if funcResp.Get("response.result").String() != "" { + t.Errorf("Expected empty response.result for image-only content, got '%s'", funcResp.Get("response.result").String()) + } + + // Image should be in functionResponse.parts[0].inlineData + inlineData := funcResp.Get("parts.0.inlineData") + if !inlineData.Exists() { + t.Fatal("functionResponse.parts[0].inlineData should exist") + } + if inlineData.Get("mimeType").String() != "image/jpeg" { + t.Errorf("Expected mimeType 'image/jpeg', got '%s'", inlineData.Get("mimeType").String()) + } + + // Image should NOT be in outer parts + outerParts := gjson.Get(outputStr, "request.contents.0.parts") + if outerParts.IsArray() && len(outerParts.Array()) > 1 { + t.Errorf("Expected only 1 outer part, got %d", len(outerParts.Array())) + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultWithMultipleImagesAndTexts(t *testing.T) { + // tool_result with array content: 2 text items + 2 images + // All images go into functionResponse.parts, texts into response.result array + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "Multi-001", + "content": [ + {"type": "text", "text": "First text"}, + { + "type": "image", + "source": {"type": "base64", "media_type": "image/png", "data": "AAAA"} + }, + {"type": "text", "text": "Second text"}, + { + "type": "image", + "source": {"type": "base64", "media_type": "image/jpeg", "data": "BBBB"} + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // Multiple text items => response.result is an array + resultArr := funcResp.Get("response.result") + if !resultArr.IsArray() { + t.Fatalf("Expected response.result to be an array, got: %s", resultArr.Raw) + } + results := resultArr.Array() + if len(results) != 2 { + t.Fatalf("Expected 2 result items, got %d", len(results)) + } + + // Both images should be in functionResponse.parts + imgParts := funcResp.Get("parts").Array() + if len(imgParts) != 2 { + t.Fatalf("Expected 2 image parts in functionResponse.parts, got %d", len(imgParts)) + } + if imgParts[0].Get("inlineData.mimeType").String() != "image/png" { + t.Errorf("Expected first image mimeType 'image/png', got '%s'", imgParts[0].Get("inlineData.mimeType").String()) + } + if imgParts[0].Get("inlineData.data").String() != "AAAA" { + t.Errorf("Expected first image data 'AAAA', got '%s'", imgParts[0].Get("inlineData.data").String()) + } + if imgParts[1].Get("inlineData.mimeType").String() != "image/jpeg" { + t.Errorf("Expected second image mimeType 'image/jpeg', got '%s'", imgParts[1].Get("inlineData.mimeType").String()) + } + if imgParts[1].Get("inlineData.data").String() != "BBBB" { + t.Errorf("Expected second image data 'BBBB', got '%s'", imgParts[1].Get("inlineData.data").String()) + } + + // Only 1 outer part (the functionResponse itself) + outerParts := gjson.Get(outputStr, "request.contents.0.parts").Array() + if len(outerParts) != 1 { + t.Errorf("Expected 1 outer part, got %d", len(outerParts)) + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultWithOnlyMultipleImages(t *testing.T) { + // tool_result with only images (no text) — response.result should be empty string + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "ImgOnly-001", + "content": [ + { + "type": "image", + "source": {"type": "base64", "media_type": "image/png", "data": "PNG1"} + }, + { + "type": "image", + "source": {"type": "base64", "media_type": "image/gif", "data": "GIF1"} + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // No text => response.result should be empty string + if funcResp.Get("response.result").String() != "" { + t.Errorf("Expected empty response.result, got '%s'", funcResp.Get("response.result").String()) + } + + // Both images in functionResponse.parts + imgParts := funcResp.Get("parts").Array() + if len(imgParts) != 2 { + t.Fatalf("Expected 2 image parts, got %d", len(imgParts)) + } + if imgParts[0].Get("inlineData.mimeType").String() != "image/png" { + t.Error("first image mimeType mismatch") + } + if imgParts[1].Get("inlineData.mimeType").String() != "image/gif" { + t.Error("second image mimeType mismatch") + } + + // Only 1 outer part + outerParts := gjson.Get(outputStr, "request.contents.0.parts").Array() + if len(outerParts) != 1 { + t.Errorf("Expected 1 outer part, got %d", len(outerParts)) + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultImageNotBase64(t *testing.T) { + // image with source.type != "base64" should be treated as non-image (falls through) + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "NotB64-001", + "content": [ + {"type": "text", "text": "some output"}, + { + "type": "image", + "source": {"type": "url", "url": "https://example.com/img.png"} + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // Non-base64 image is treated as non-image, so it goes into the filtered results + // along with the text item. Since there are 2 non-image items, result is array. + resultArr := funcResp.Get("response.result") + if !resultArr.IsArray() { + t.Fatalf("Expected response.result to be an array (2 non-image items), got: %s", resultArr.Raw) + } + results := resultArr.Array() + if len(results) != 2 { + t.Fatalf("Expected 2 result items, got %d", len(results)) + } + + // No functionResponse.parts (no base64 images collected) + if funcResp.Get("parts").Exists() { + t.Error("functionResponse.parts should NOT exist when no base64 images") + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultImageMissingData(t *testing.T) { + // image with source.type=base64 but missing data field + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "NoData-001", + "content": [ + {"type": "text", "text": "output"}, + { + "type": "image", + "source": {"type": "base64", "media_type": "image/png"} + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // The image is still classified as base64 image (type check passes), + // but data field is missing => inlineData has mimeType but no data + imgParts := funcResp.Get("parts").Array() + if len(imgParts) != 1 { + t.Fatalf("Expected 1 image part, got %d", len(imgParts)) + } + if imgParts[0].Get("inlineData.mimeType").String() != "image/png" { + t.Error("mimeType should still be set") + } + if imgParts[0].Get("inlineData.data").Exists() { + t.Error("data should not exist when source.data is missing") + } +} + +func TestConvertClaudeRequestToAntigravity_ToolResultImageMissingMediaType(t *testing.T) { + // image with source.type=base64 but missing media_type field + inputJSON := []byte(`{ + "model": "claude-3-5-sonnet-20240620", + "messages": [ + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "NoMime-001", + "content": [ + {"type": "text", "text": "output"}, + { + "type": "image", + "source": {"type": "base64", "data": "AAAA"} + } + ] + } + ] + } + ] + }`) + + output := ConvertClaudeRequestToAntigravity("claude-sonnet-4-5", inputJSON, false) + outputStr := string(output) + + if !gjson.Valid(outputStr) { + t.Fatalf("Result is not valid JSON:\n%s", outputStr) + } + + funcResp := gjson.Get(outputStr, "request.contents.0.parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist") + } + + // The image is still classified as base64 image, + // but media_type is missing => inlineData has data but no mimeType + imgParts := funcResp.Get("parts").Array() + if len(imgParts) != 1 { + t.Fatalf("Expected 1 image part, got %d", len(imgParts)) + } + if imgParts[0].Get("inlineData.mimeType").Exists() { + t.Error("mimeType should not exist when media_type is missing") + } + if imgParts[0].Get("inlineData.data").String() != "AAAA" { + t.Error("data should still be set") + } +} + func TestConvertClaudeRequestToAntigravity_ToolAndThinking_NoExistingSystem(t *testing.T) { // When tools + thinking but no system instruction, should create one with hint inputJSON := []byte(`{ diff --git a/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go b/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go index 8867a30e..da581d1a 100644 --- a/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go +++ b/internal/translator/antigravity/gemini/antigravity_gemini_request_test.go @@ -93,3 +93,81 @@ func TestConvertGeminiRequestToAntigravity_ParallelFunctionCalls(t *testing.T) { } } } + +func TestFixCLIToolResponse_PreservesFunctionResponseParts(t *testing.T) { + // When functionResponse contains a "parts" field with inlineData (from Claude + // translator's image embedding), fixCLIToolResponse should preserve it as-is. + // parseFunctionResponseRaw returns response.Raw for valid JSON objects, + // so extra fields like "parts" survive the pipeline. + input := `{ + "model": "claude-opus-4-6-thinking", + "request": { + "contents": [ + { + "role": "model", + "parts": [ + { + "functionCall": {"name": "screenshot", "args": {}} + } + ] + }, + { + "role": "function", + "parts": [ + { + "functionResponse": { + "id": "tool-001", + "name": "screenshot", + "response": {"result": "Screenshot taken"}, + "parts": [ + {"inlineData": {"mimeType": "image/png", "data": "iVBOR"}} + ] + } + } + ] + } + ] + } + }` + + result, err := fixCLIToolResponse(input) + if err != nil { + t.Fatalf("fixCLIToolResponse failed: %v", err) + } + + // Find the function response content (role=function) + contents := gjson.Get(result, "request.contents").Array() + var funcContent gjson.Result + for _, c := range contents { + if c.Get("role").String() == "function" { + funcContent = c + break + } + } + if !funcContent.Exists() { + t.Fatal("function role content should exist in output") + } + + // The functionResponse should be preserved with its parts field + funcResp := funcContent.Get("parts.0.functionResponse") + if !funcResp.Exists() { + t.Fatal("functionResponse should exist in output") + } + + // Verify the parts field with inlineData is preserved + inlineParts := funcResp.Get("parts").Array() + if len(inlineParts) != 1 { + t.Fatalf("Expected 1 inlineData part in functionResponse.parts, got %d", len(inlineParts)) + } + if inlineParts[0].Get("inlineData.mimeType").String() != "image/png" { + t.Errorf("Expected mimeType 'image/png', got '%s'", inlineParts[0].Get("inlineData.mimeType").String()) + } + if inlineParts[0].Get("inlineData.data").String() != "iVBOR" { + t.Errorf("Expected data 'iVBOR', got '%s'", inlineParts[0].Get("inlineData.data").String()) + } + + // Verify response.result is also preserved + if funcResp.Get("response.result").String() != "Screenshot taken" { + t.Errorf("Expected response.result 'Screenshot taken', got '%s'", funcResp.Get("response.result").String()) + } +} diff --git a/internal/translator/antigravity/openai/chat-completions/antigravity_openai_request.go b/internal/translator/antigravity/openai/chat-completions/antigravity_openai_request.go index a8105c4e..85b28b8b 100644 --- a/internal/translator/antigravity/openai/chat-completions/antigravity_openai_request.go +++ b/internal/translator/antigravity/openai/chat-completions/antigravity_openai_request.go @@ -187,7 +187,7 @@ func ConvertOpenAIRequestToAntigravity(modelName string, inputRawJSON []byte, _ if len(pieces) == 2 && len(pieces[1]) > 7 { mime := pieces[0] data := pieces[1][7:] - node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mime_type", mime) + node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mimeType", mime) node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.data", data) node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".thoughtSignature", geminiCLIFunctionThoughtSignature) p++ @@ -201,7 +201,7 @@ func ConvertOpenAIRequestToAntigravity(modelName string, inputRawJSON []byte, _ ext = sp[len(sp)-1] } if mimeType, ok := misc.MimeTypes[ext]; ok { - node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mime_type", mimeType) + node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mimeType", mimeType) node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.data", fileData) p++ } else { @@ -235,7 +235,7 @@ func ConvertOpenAIRequestToAntigravity(modelName string, inputRawJSON []byte, _ if len(pieces) == 2 && len(pieces[1]) > 7 { mime := pieces[0] data := pieces[1][7:] - node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mime_type", mime) + node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.mimeType", mime) node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".inlineData.data", data) node, _ = sjson.SetBytes(node, "parts."+itoa(p)+".thoughtSignature", geminiCLIFunctionThoughtSignature) p++ diff --git a/sdk/cliproxy/service.go b/sdk/cliproxy/service.go index 2bd12d0a..5e535343 100644 --- a/sdk/cliproxy/service.go +++ b/sdk/cliproxy/service.go @@ -963,6 +963,9 @@ func (s *Service) registerModelsForAuth(a *coreauth.Auth) { key = strings.ToLower(strings.TrimSpace(a.Provider)) } GlobalModelRegistry().RegisterClient(a.ID, key, applyModelPrefixes(models, a.Prefix, s.cfg != nil && s.cfg.ForceModelPrefix)) + if provider == "antigravity" { + s.backfillAntigravityModels(a, models) + } return } @@ -1107,6 +1110,56 @@ func (s *Service) oauthExcludedModels(provider, authKind string) []string { return cfg.OAuthExcludedModels[providerKey] } +func (s *Service) backfillAntigravityModels(source *coreauth.Auth, primaryModels []*ModelInfo) { + if s == nil || s.coreManager == nil || len(primaryModels) == 0 { + return + } + + sourceID := "" + if source != nil { + sourceID = strings.TrimSpace(source.ID) + } + + reg := registry.GetGlobalRegistry() + for _, candidate := range s.coreManager.List() { + if candidate == nil || candidate.Disabled { + continue + } + candidateID := strings.TrimSpace(candidate.ID) + if candidateID == "" || candidateID == sourceID { + continue + } + if !strings.EqualFold(strings.TrimSpace(candidate.Provider), "antigravity") { + continue + } + if len(reg.GetModelsForClient(candidateID)) > 0 { + continue + } + + authKind := strings.ToLower(strings.TrimSpace(candidate.Attributes["auth_kind"])) + if authKind == "" { + if kind, _ := candidate.AccountInfo(); strings.EqualFold(kind, "api_key") { + authKind = "apikey" + } + } + excluded := s.oauthExcludedModels("antigravity", authKind) + if candidate.Attributes != nil { + if val, ok := candidate.Attributes["excluded_models"]; ok && strings.TrimSpace(val) != "" { + excluded = strings.Split(val, ",") + } + } + + models := applyExcludedModels(primaryModels, excluded) + models = applyOAuthModelAlias(s.cfg, "antigravity", authKind, models) + if len(models) == 0 { + continue + } + + reg.RegisterClient(candidateID, "antigravity", applyModelPrefixes(models, candidate.Prefix, s.cfg != nil && s.cfg.ForceModelPrefix)) + log.Debugf("antigravity models backfilled for auth %s using primary model list", candidateID) + } +} + func applyExcludedModels(models []*ModelInfo, excluded []string) []*ModelInfo { if len(models) == 0 || len(excluded) == 0 { return models diff --git a/sdk/cliproxy/service_antigravity_backfill_test.go b/sdk/cliproxy/service_antigravity_backfill_test.go new file mode 100644 index 00000000..df087438 --- /dev/null +++ b/sdk/cliproxy/service_antigravity_backfill_test.go @@ -0,0 +1,135 @@ +package cliproxy + +import ( + "context" + "strings" + "testing" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + coreauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth" + "github.com/router-for-me/CLIProxyAPI/v6/sdk/config" +) + +func TestBackfillAntigravityModels_RegistersMissingAuth(t *testing.T) { + source := &coreauth.Auth{ + ID: "ag-backfill-source", + Provider: "antigravity", + Status: coreauth.StatusActive, + Attributes: map[string]string{ + "auth_kind": "oauth", + }, + } + target := &coreauth.Auth{ + ID: "ag-backfill-target", + Provider: "antigravity", + Status: coreauth.StatusActive, + Attributes: map[string]string{ + "auth_kind": "oauth", + }, + } + + manager := coreauth.NewManager(nil, nil, nil) + if _, err := manager.Register(context.Background(), source); err != nil { + t.Fatalf("register source auth: %v", err) + } + if _, err := manager.Register(context.Background(), target); err != nil { + t.Fatalf("register target auth: %v", err) + } + + service := &Service{ + cfg: &config.Config{}, + coreManager: manager, + } + + reg := registry.GetGlobalRegistry() + reg.UnregisterClient(source.ID) + reg.UnregisterClient(target.ID) + t.Cleanup(func() { + reg.UnregisterClient(source.ID) + reg.UnregisterClient(target.ID) + }) + + primary := []*ModelInfo{ + {ID: "claude-sonnet-4-5"}, + {ID: "gemini-2.5-pro"}, + } + reg.RegisterClient(source.ID, "antigravity", primary) + + service.backfillAntigravityModels(source, primary) + + got := reg.GetModelsForClient(target.ID) + if len(got) != 2 { + t.Fatalf("expected target auth to be backfilled with 2 models, got %d", len(got)) + } + + ids := make(map[string]struct{}, len(got)) + for _, model := range got { + if model == nil { + continue + } + ids[strings.ToLower(strings.TrimSpace(model.ID))] = struct{}{} + } + if _, ok := ids["claude-sonnet-4-5"]; !ok { + t.Fatal("expected backfilled model claude-sonnet-4-5") + } + if _, ok := ids["gemini-2.5-pro"]; !ok { + t.Fatal("expected backfilled model gemini-2.5-pro") + } +} + +func TestBackfillAntigravityModels_RespectsExcludedModels(t *testing.T) { + source := &coreauth.Auth{ + ID: "ag-backfill-source-excluded", + Provider: "antigravity", + Status: coreauth.StatusActive, + Attributes: map[string]string{ + "auth_kind": "oauth", + }, + } + target := &coreauth.Auth{ + ID: "ag-backfill-target-excluded", + Provider: "antigravity", + Status: coreauth.StatusActive, + Attributes: map[string]string{ + "auth_kind": "oauth", + "excluded_models": "gemini-2.5-pro", + }, + } + + manager := coreauth.NewManager(nil, nil, nil) + if _, err := manager.Register(context.Background(), source); err != nil { + t.Fatalf("register source auth: %v", err) + } + if _, err := manager.Register(context.Background(), target); err != nil { + t.Fatalf("register target auth: %v", err) + } + + service := &Service{ + cfg: &config.Config{}, + coreManager: manager, + } + + reg := registry.GetGlobalRegistry() + reg.UnregisterClient(source.ID) + reg.UnregisterClient(target.ID) + t.Cleanup(func() { + reg.UnregisterClient(source.ID) + reg.UnregisterClient(target.ID) + }) + + primary := []*ModelInfo{ + {ID: "claude-sonnet-4-5"}, + {ID: "gemini-2.5-pro"}, + } + reg.RegisterClient(source.ID, "antigravity", primary) + + service.backfillAntigravityModels(source, primary) + + got := reg.GetModelsForClient(target.ID) + if len(got) != 1 { + t.Fatalf("expected 1 model after exclusion, got %d", len(got)) + } + if got[0] == nil || !strings.EqualFold(strings.TrimSpace(got[0].ID), "claude-sonnet-4-5") { + t.Fatalf("expected remaining model %q, got %+v", "claude-sonnet-4-5", got[0]) + } +}