feat(antigravity): support native Claude web search

Author: sususu98

internal/registry/model_definitions.go

@@ -3,6 +3,7 @@
 package registry
 
 import (
+	"sort"
 	"strings"
 )
 
@@ -85,6 +86,66 @@ func GetAntigravityModels() []*ModelInfo {
 	return cloneModelInfos(getModels().Antigravity)
 }
 
+// AntigravityWebSearchModels returns models listed by
+// fetchAvailableModels.webSearchModelIds.
+func AntigravityWebSearchModels() []string {
+	out := make([]string, 0)
+	for _, model := range GetGlobalRegistry().GetAvailableModelsByProvider("antigravity") {
+		if model == nil || !model.SupportsWebSearch {
+			continue
+		}
+		modelID := normalizeAntigravityCapabilityModelID(model.ID)
+		if modelID != "" {
+			out = append(out, modelID)
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+// AntigravityWebSearchModelFor returns the Antigravity model that should run a
+// native web search request for modelID.
+func AntigravityWebSearchModelFor(modelID string) string {
+	modelID = normalizeAntigravityCapabilityModelID(modelID)
+	if modelID == "" {
+		return ""
+	}
+	for _, model := range GetGlobalRegistry().GetAvailableModelsByProvider("antigravity") {
+		if model == nil {
+			continue
+		}
+		currentModelID := normalizeAntigravityCapabilityModelID(model.ID)
+		if currentModelID == "" {
+			continue
+		}
+		if currentModelID == modelID {
+			if model.SupportsWebSearch {
+				return currentModelID
+			}
+			return ""
+		}
+	}
+	return ""
+}
+
+// IsAntigravityWebSearchModel reports whether an Antigravity model is listed by
+// fetchAvailableModels.webSearchModelIds and can run the native googleSearch tool.
+func IsAntigravityWebSearchModel(modelID string) bool {
+	modelID = normalizeAntigravityCapabilityModelID(modelID)
+	if modelID == "" {
+		return false
+	}
+	for _, model := range GetGlobalRegistry().GetAvailableModelsByProvider("antigravity") {
+		if model == nil {
+			continue
+		}
+		if normalizeAntigravityCapabilityModelID(model.ID) == modelID {
+			return model.SupportsWebSearch
+		}
+	}
+	return false
+}
+
 // GetXAIModels returns the standard xAI Grok model definitions.
 func GetXAIModels() []*ModelInfo {
 	return WithXAIBuiltins(cloneModelInfos(getModels().XAI))
@@ -103,6 +164,14 @@ func WithXAIBuiltins(models []*ModelInfo) []*ModelInfo {
 	return upsertModelInfos(models, xaiBuiltinImageModelInfo(), xaiBuiltinImageQualityModelInfo(), xaiBuiltinVideoModelInfo(), xaiBuiltinVideo15PreviewModelInfo())
 }
 
+func normalizeAntigravityCapabilityModelID(modelID string) string {
+	modelID = strings.ToLower(strings.TrimSpace(modelID))
+	if open := strings.LastIndex(modelID, "("); open >= 0 && strings.HasSuffix(modelID, ")") {
+		modelID = strings.TrimSpace(modelID[:open])
+	}
+	return modelID
+}
+
 func codexBuiltinImageModelInfo() *ModelInfo {
 	return &ModelInfo{
 		ID:          codexBuiltinImageModelID,

internal/registry/model_definitions_test.go

@@ -16,3 +16,85 @@ func TestWithXAIBuiltinsIncludesVideoPreviewModel(t *testing.T) {
 
 	t.Fatalf("expected xAI builtin model %s", xaiBuiltinVideo15PreviewModelID)
 }
+
+func TestIsAntigravityWebSearchModelUsesRuntimeCapability(t *testing.T) {
+	registryRef := GetGlobalRegistry()
+	registryRef.RegisterClient("test-antigravity-websearch", "antigravity", []*ModelInfo{
+		{ID: "gemini-web-search-test", SupportsWebSearch: true},
+		{ID: "gemini-web-search-disabled", SupportsWebSearch: false},
+	})
+	registryRef.RegisterClient("test-gemini-websearch", "gemini", []*ModelInfo{
+		{ID: "gemini-web-search-cross-provider", SupportsWebSearch: true},
+	})
+	t.Cleanup(func() {
+		registryRef.UnregisterClient("test-antigravity-websearch")
+		registryRef.UnregisterClient("test-gemini-websearch")
+	})
+
+	if !IsAntigravityWebSearchModel("gemini-web-search-test") {
+		t.Fatal("runtime Antigravity web search model should be marked capable")
+	}
+	if !IsAntigravityWebSearchModel("gemini-web-search-test(high)") {
+		t.Fatal("thinking suffix should not hide Antigravity web search capability")
+	}
+	if IsAntigravityWebSearchModel("gemini-web-search-disabled") {
+		t.Fatal("Antigravity model without web search support should not be marked capable")
+	}
+	if IsAntigravityWebSearchModel("gemini-web-search-cross-provider") {
+		t.Fatal("same capability on another provider should not mark Antigravity capable")
+	}
+}
+
+func TestAntigravityWebSearchModelsUsesRuntimeCapability(t *testing.T) {
+	registryRef := GetGlobalRegistry()
+	registryRef.RegisterClient("test-antigravity-websearch-list", "antigravity", []*ModelInfo{
+		{ID: "gemini-web-search-test", SupportsWebSearch: true},
+		{ID: "gemini-web-search-disabled", SupportsWebSearch: false},
+	})
+	t.Cleanup(func() {
+		registryRef.UnregisterClient("test-antigravity-websearch-list")
+	})
+
+	models := AntigravityWebSearchModels()
+	if len(models) == 0 {
+		t.Fatal("expected at least one Antigravity web search model")
+	}
+	for _, model := range models {
+		if model == "gemini-web-search-test" {
+			return
+		}
+	}
+	t.Fatalf("AntigravityWebSearchModels() = %#v, want gemini-web-search-test", models)
+}
+
+func TestAntigravityWebSearchModelForRequiresRequestedModelCapability(t *testing.T) {
+	registryRef := GetGlobalRegistry()
+	registryRef.RegisterClient("test-antigravity-websearch-route", "antigravity", []*ModelInfo{
+		{ID: "gemini-route-test"},
+		{ID: "gemini-web-search-test", SupportsWebSearch: true},
+	})
+	registryRef.RegisterClient("test-gemini-websearch-route", "gemini", []*ModelInfo{
+		{ID: "gemini-cross-provider-route"},
+		{ID: "gemini-cross-provider-search", SupportsWebSearch: true},
+	})
+	t.Cleanup(func() {
+		registryRef.UnregisterClient("test-antigravity-websearch-route")
+		registryRef.UnregisterClient("test-gemini-websearch-route")
+	})
+
+	if got := AntigravityWebSearchModelFor("gemini-route-test"); got != "" {
+		t.Fatalf("route model without web search support should not get fallback model, got %q", got)
+	}
+	if got := AntigravityWebSearchModelFor("gemini-route-test(high)"); got != "" {
+		t.Fatalf("suffix route model without web search support should not get fallback model, got %q", got)
+	}
+	if got := AntigravityWebSearchModelFor("gemini-web-search-test"); got != "gemini-web-search-test" {
+		t.Fatalf("AntigravityWebSearchModelFor capable model = %q, want itself", got)
+	}
+	if got := AntigravityWebSearchModelFor("gemini-cross-provider-route"); got != "" {
+		t.Fatalf("cross-provider model should not get Antigravity web search model, got %q", got)
+	}
+	if got := AntigravityWebSearchModelFor("unknown-model"); got != "" {
+		t.Fatalf("unknown model should not get Antigravity web search model, got %q", got)
+	}
+}

internal/registry/model_registry.go

@@ -54,6 +54,9 @@ type ModelInfo struct {
 	SupportedInputModalities []string `json:"supportedInputModalities,omitempty"`
 	// SupportedOutputModalities lists supported output modalities (e.g., TEXT, IMAGE)
 	SupportedOutputModalities []string `json:"supportedOutputModalities,omitempty"`
+	// SupportsWebSearch indicates the provider can execute a native web search
+	// tool for this model.
+	SupportsWebSearch bool `json:"supports_web_search,omitempty"`
 
 	// Thinking holds provider-specific reasoning/thinking budget capabilities.
 	// This is optional and currently used for Gemini thinking budget normalization.

internal/runtime/executor/antigravity_executor.go

@@ -2050,11 +2050,15 @@ func (e *AntigravityExecutor) buildRequest(ctx context.Context, auth *cliproxyau
 		return nil, errProject
 	}
 	payload = geminiToAntigravity(modelName, payload, projectID)
-	payload, _ = sjson.SetBytes(payload, "model", modelName)
+	effectiveModelName := strings.TrimSpace(gjson.GetBytes(payload, "model").String())
+	if effectiveModelName == "" {
+		effectiveModelName = modelName
+		payload, _ = sjson.SetBytes(payload, "model", effectiveModelName)
+	}
 
 	// Cap maxOutputTokens to model's max_completion_tokens from registry
 	if maxOut := gjson.GetBytes(payload, "request.generationConfig.maxOutputTokens"); maxOut.Exists() && maxOut.Type == gjson.Number {
-		if modelInfo := registry.LookupModelInfo(modelName, "antigravity"); modelInfo != nil && modelInfo.MaxCompletionTokens > 0 {
+		if modelInfo := registry.LookupModelInfo(effectiveModelName, "antigravity"); modelInfo != nil && modelInfo.MaxCompletionTokens > 0 {
 			if int(maxOut.Int()) > modelInfo.MaxCompletionTokens {
 				payload, _ = sjson.SetBytes(payload, "request.generationConfig.maxOutputTokens", modelInfo.MaxCompletionTokens)
 			}
@@ -2464,11 +2468,15 @@ func resolveCustomAntigravityBaseURL(auth *cliproxyauth.Auth) string {
 }
 
 func geminiToAntigravity(modelName string, payload []byte, projectID string) []byte {
+	effectiveModelName := strings.TrimSpace(gjson.GetBytes(payload, "model").String())
+	if effectiveModelName == "" {
+		effectiveModelName = modelName
+	}
 	template := payload
-	template, _ = sjson.SetBytes(template, "model", modelName)
+	template, _ = sjson.SetBytes(template, "model", effectiveModelName)
 	template, _ = sjson.SetBytes(template, "userAgent", "antigravity")
 
-	isImageModel := strings.Contains(modelName, "image")
+	isImageModel := strings.Contains(effectiveModelName, "image")
 
 	var reqType string
 	if isImageModel {

internal/runtime/executor/antigravity_executor_buildrequest_test.go

@@ -110,6 +110,25 @@ func TestAntigravityBuildRequest_UsesAuthProjectID(t *testing.T) {
 	}
 }
 
+func TestAntigravityBuildRequest_PreservesTranslatedModel(t *testing.T) {
+	body := buildRequestBodyFromRawPayload(t, "gemini-3-flash-agent", []byte(`{
+		"model": "gemini-3.1-flash-lite",
+		"request": {
+			"contents": [
+				{
+					"role": "user",
+					"parts": [{"text": "Perform a web search"}]
+				}
+			],
+			"tools": [{"googleSearch": {}}]
+		}
+	}`))
+
+	if got, ok := body["model"].(string); !ok || got != "gemini-3.1-flash-lite" {
+		t.Fatalf("translated model should be preserved, got=%v", body["model"])
+	}
+}
+
 func TestAntigravityPrepareRequestAuth_FetchesMissingProjectID(t *testing.T) {
 	executor := &AntigravityExecutor{}
 	auth := &cliproxyauth.Auth{Metadata: map[string]any{

internal/translator/antigravity/claude/antigravity_claude_request.go

@@ -592,13 +592,21 @@ func ConvertClaudeRequestToAntigravity(modelName string, inputRawJSON []byte, _
 	// tools
 	var toolsJSON []byte
 	toolDeclCount := 0
+	googleSearchToolCount := 0
+	googleSearchModelName := antigravityNativeGoogleSearchModel(modelName)
 	allowedToolKeys := []string{"name", "description", "behavior", "parameters", "parametersJsonSchema", "response", "responseJsonSchema"}
 	toolsResult := gjson.GetBytes(rawJSON, "tools")
 	if toolsResult.IsArray() {
-		toolsJSON = []byte(`[{"functionDeclarations":[]}]`)
+		functionToolNode := []byte(`{"functionDeclarations":[]}`)
+		googleSearchNodes := make([][]byte, 0)
 		toolsResults := toolsResult.Array()
 		for i := 0; i < len(toolsResults); i++ {
 			toolResult := toolsResults[i]
+			if isClaudeTypedWebSearchToolType(toolResult.Get("type").String()) && googleSearchModelName != "" {
+				googleSearchNodes = append(googleSearchNodes, []byte(`{"googleSearch":{}}`))
+				googleSearchToolCount++
+				continue
+			}
 			inputSchemaResult := toolResult.Get("input_schema")
 			if inputSchemaResult.Exists() && inputSchemaResult.IsObject() {
 				// Sanitize the input schema for Antigravity API compatibility
@@ -612,18 +620,31 @@ func ConvertClaudeRequestToAntigravity(modelName string, inputRawJSON []byte, _
 					}
 					tool, _ = sjson.DeleteBytes(tool, toolKey)
 				}
-				toolsJSON, _ = sjson.SetRawBytes(toolsJSON, "0.functionDeclarations.-1", tool)
+				functionToolNode, _ = sjson.SetRawBytes(functionToolNode, "functionDeclarations.-1", tool)
 				toolDeclCount++
 			}
 		}
+		if toolDeclCount > 0 || len(googleSearchNodes) > 0 {
+			toolsJSON = []byte(`[]`)
+			if toolDeclCount > 0 {
+				toolsJSON, _ = sjson.SetRawBytes(toolsJSON, "-1", functionToolNode)
+			}
+			for _, googleSearchNode := range googleSearchNodes {
+				toolsJSON, _ = sjson.SetRawBytes(toolsJSON, "-1", googleSearchNode)
+			}
+		}
 	}
 
 	// Build output Gemini CLI request JSON
 	out := []byte(`{"model":"","request":{"contents":[]}}`)
-	out, _ = sjson.SetBytes(out, "model", modelName)
+	outputModelName := modelName
+	if googleSearchToolCount > 0 {
+		outputModelName = googleSearchModelName
+	}
+	out, _ = sjson.SetBytes(out, "model", outputModelName)
 
 	// Inject interleaved thinking hint when both tools and thinking are active
-	hasTools := toolDeclCount > 0
+	hasTools := toolDeclCount > 0 || googleSearchToolCount > 0
 	thinkingResult := gjson.GetBytes(rawJSON, "thinking")
 	thinkingType := thinkingResult.Get("type").String()
 	hasThinking := thinkingResult.Exists() && thinkingResult.IsObject() && (thinkingType == "enabled" || thinkingType == "adaptive" || thinkingType == "auto")
@@ -653,7 +674,7 @@ func ConvertClaudeRequestToAntigravity(modelName string, inputRawJSON []byte, _
 	if hasContents {
 		out, _ = sjson.SetRawBytes(out, "request.contents", contentsJSON)
 	}
-	if toolDeclCount > 0 {
+	if toolDeclCount > 0 || googleSearchToolCount > 0 {
 		out, _ = sjson.SetRawBytes(out, "request.tools", toolsJSON)
 	}