fix(antigravity): Gemini 原生请求的裸模型名按 thinkingConfig 解析到 -low/-medium/-high 变体

Antigravity CLI / go-genai 发裸 Gemini 模型名（gemini-3.8-flash）并用
generationConfig.thinkingConfig 表达思考深度，而 Antigravity 上游目录只有
-low/-medium/-high/-tiered 变体。v0.2.5 起 resolveModelMapping 会给 antigravity
账号运行时补 gemini-3.x-flash 裸名自映射，裸名因此被当成显式透传直发上游，
上游回 404 "Requested entity was not found."。

在 ForwardGemini 取映射之前加 resolveGeminiThinkingVariant：
- 仅对 gemini- 前缀且不带后缀的裸名生效；
- 用户在 credentials.model_mapping 亲写的裸名条目一律不介入，运行时注入的
  默认自映射不算用户意图；
- thinkingLevel 优先；否则 thinkingBudget <0→high，≤1024→low，≤8192→medium，
  其余 high；未携带 thinkingConfig→high；所选变体不存在时按
  high→medium→low→tiered 降级；一个变体都没有则回退原逻辑；
- thinkingConfig 仍原样透传，上游按 budget 决定实际思考量。

Author: HuntercodeT

backend/internal/service/antigravity_gateway_gemini.go

@@ -86,7 +86,14 @@ func (s *AntigravityGatewayService) ForwardGemini(ctx context.Context, c *gin.Co
 		return nil, s.writeGoogleError(c, http.StatusNotFound, "Unsupported action: "+action)
 	}
 
-	mappedModel := s.getMappedModel(account, originalModel)
+	// 裸模型名（gemini-3.8-flash）+ thinkingConfig → 账号映射表里对应的 -low/-medium/-high 变体；
+	// 裸名有显式映射时保持原行为。
+	mappedModel, variantResolved := resolveGeminiThinkingVariant(account, originalModel, body)
+	if !variantResolved {
+		mappedModel = s.getMappedModel(account, originalModel)
+	} else {
+		logger.LegacyPrintf("service.antigravity_gateway", "%s resolved bare Gemini model %s to thinking variant %s", prefix, originalModel, mappedModel)
+	}
 	if mappedModel == "" {
 		MarkOpsClientBusinessLimited(c, OpsClientBusinessLimitedReasonLocalFeatureGate)
 		return nil, s.writeGoogleError(c, http.StatusForbidden, fmt.Sprintf("model %s not in whitelist", originalModel))

backend/internal/service/antigravity_gemini_thinking_variant.go

@@ -0,0 +1,137 @@
+package service
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// Gemini 原生请求（/v1beta/models/{model}:generateContent 等）经 Antigravity 账号转发时，
+// 客户端（如 Antigravity CLI / go-genai）习惯发"裸"模型名（gemini-3.8-flash）并用
+// generationConfig.thinkingConfig 表达思考深度；而 Antigravity 上游的模型目录只有
+// gemini-3.8-flash-low / -medium / -high / -tiered 这类带后缀的变体，裸名直接转发会被上游
+// 以 404 "Requested entity was not found." 拒绝。
+//
+// 这里在账号 model_mapping 没有为裸名配置显式条目、但配置了它的后缀变体时，
+// 按 thinkingConfig 自动挑一个变体：
+//   - thinkingLevel: "low" / "medium" / "high" → 同名后缀
+//   - thinkingBudget: -1（动态）→ high；0 → low；1..1024 → low；1025..8192 → medium；>8192 → high
+//   - 未携带 thinkingConfig → high（与 Gemini 3 系列默认开启动态思考一致）
+// 选中的后缀在映射表里不存在时按 high → medium → low → tiered 的顺序降级到存在的变体。
+// 显式映射（裸名本身在 model_mapping 里）始终优先，行为与现在完全一致。
+
+var geminiThinkingVariantSuffixes = []string{"-low", "-medium", "-high", "-tiered"}
+
+const (
+	geminiThinkingBudgetLowMax    = 1024
+	geminiThinkingBudgetMediumMax = 8192
+)
+
+type geminiThinkingConfigProbe struct {
+	GenerationConfig struct {
+		ThinkingConfig *struct {
+			ThinkingBudget *json.Number `json:"thinkingBudget"`
+			ThinkingLevel  string       `json:"thinkingLevel"`
+		} `json:"thinkingConfig"`
+	} `json:"generationConfig"`
+}
+
+// hasGeminiThinkingVariantSuffix 判断模型名是否已经带了思考深度后缀。
+func hasGeminiThinkingVariantSuffix(model string) bool {
+	for _, suffix := range geminiThinkingVariantSuffixes {
+		if strings.HasSuffix(model, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+// geminiThinkingLevelFromBody 从 Gemini 原生请求体推导期望的思考档位（low/medium/high）。
+// 解析失败或未携带 thinkingConfig 时返回 "high"。
+func geminiThinkingLevelFromBody(body []byte) string {
+	if len(body) == 0 {
+		return "high"
+	}
+	var probe geminiThinkingConfigProbe
+	if err := json.Unmarshal(body, &probe); err != nil || probe.GenerationConfig.ThinkingConfig == nil {
+		return "high"
+	}
+	tc := probe.GenerationConfig.ThinkingConfig
+	switch strings.ToLower(strings.TrimSpace(tc.ThinkingLevel)) {
+	case "low":
+		return "low"
+	case "medium":
+		return "medium"
+	case "high":
+		return "high"
+	}
+	if tc.ThinkingBudget == nil {
+		return "high"
+	}
+	budget, err := tc.ThinkingBudget.Float64()
+	if err != nil {
+		return "high"
+	}
+	switch {
+	case budget < 0:
+		return "high" // -1 = 动态思考
+	case budget <= geminiThinkingBudgetLowMax:
+		return "low" // 含 0（关闭思考）：上游没有"无思考"变体，取最浅档，budget 本身仍原样透传
+	case budget <= geminiThinkingBudgetMediumMax:
+		return "medium"
+	default:
+		return "high"
+	}
+}
+
+// accountRawModelMappingHasKey 判断 key 是否由用户写在账号 credentials.model_mapping 里
+// （而不是 resolveModelMapping 运行时补进来的默认透传条目）。
+func accountRawModelMappingHasKey(account *Account, key string) bool {
+	if account == nil || account.Credentials == nil {
+		return false
+	}
+	raw, _ := account.Credentials["model_mapping"].(map[string]any)
+	_, ok := raw[key]
+	return ok
+}
+
+// resolveGeminiThinkingVariant 为裸 Gemini 模型名挑选账号映射表里存在的思考深度变体。
+// 返回 (映射后的上游模型名, 是否命中)。未命中时调用方应回退到常规 getMappedModel 流程。
+func resolveGeminiThinkingVariant(account *Account, requestedModel string, body []byte) (string, bool) {
+	if account == nil {
+		return "", false
+	}
+	model := strings.TrimSpace(strings.TrimPrefix(requestedModel, "models/"))
+	if !strings.HasPrefix(model, "gemini-") || hasGeminiThinkingVariantSuffix(model) {
+		return "", false
+	}
+	mapping := account.GetModelMapping()
+	if len(mapping) == 0 {
+		return "", false
+	}
+	// 裸名本身已有"真正的"映射 → 尊重现有配置，不做推导。判定分两层：
+	//   1. 映射目标不是自己（如 gemini-3.8-flash → gemini-3.8-flash-tiered）：用户明确指定了目标；
+	//   2. 映射目标是自己（原样透传）：仅当这条是用户亲手写进 credentials.model_mapping 的才尊重。
+	//      resolveModelMapping 会给每个 Antigravity 账号自动补 gemini-3.x-flash 裸名自映射
+	//      （ensureAntigravityDefaultPassthroughs），而上游目录里并没有裸名模型，那条自映射
+	//      正是导致 404 的来源，不能算作用户意图。
+	if mapped, matched := resolveRequestedModelInMapping(mapping, model); matched {
+		if strings.TrimSpace(mapped) != model || accountRawModelMappingHasKey(account, model) {
+			return "", false
+		}
+	}
+
+	preferred := geminiThinkingLevelFromBody(body)
+	order := []string{preferred}
+	for _, level := range []string{"high", "medium", "low", "tiered"} {
+		if level != preferred {
+			order = append(order, level)
+		}
+	}
+	for _, level := range order {
+		candidate := model + "-" + level
+		if mapped, matched := resolveRequestedModelInMapping(mapping, candidate); matched && strings.TrimSpace(mapped) != "" {
+			return mapped, true
+		}
+	}
+	return "", false
+}

backend/internal/service/antigravity_gemini_thinking_variant_test.go

@@ -0,0 +1,118 @@
+package service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func newAntigravityAccountWithMapping(mapping map[string]string) *Account {
+	mappingAny := make(map[string]any, len(mapping))
+	for k, v := range mapping {
+		mappingAny[k] = v
+	}
+	return &Account{
+		ID:       1,
+		Name:     "ag",
+		Platform: PlatformAntigravity,
+		Credentials: map[string]any{
+			"model_mapping": mappingAny,
+		},
+	}
+}
+
+func TestGeminiThinkingLevelFromBody(t *testing.T) {
+	tests := []struct {
+		name string
+		body string
+		want string
+	}{
+		{"empty body", ``, "high"},
+		{"no thinkingConfig", `{"contents":[]}`, "high"},
+		{"budget -1 dynamic", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":-1}}}`, "high"},
+		{"budget 0 off", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":0}}}`, "low"},
+		{"budget 1000 (agy low)", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":1000}}}`, "low"},
+		{"budget 4000 (agy medium)", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":4000}}}`, "medium"},
+		{"budget 24576", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":24576}}}`, "high"},
+		{"thinkingLevel wins over budget", `{"generationConfig":{"thinkingConfig":{"thinkingBudget":24576,"thinkingLevel":"low"}}}`, "low"},
+		{"thinkingLevel medium", `{"generationConfig":{"thinkingConfig":{"thinkingLevel":"MEDIUM"}}}`, "medium"},
+		{"invalid json", `{"generationConfig":`, "high"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.want, geminiThinkingLevelFromBody([]byte(tt.body)))
+		})
+	}
+}
+
+func TestResolveGeminiThinkingVariant(t *testing.T) {
+	// 与生产 Antigravity 账号从上游同步来的目录一致：只有带后缀的变体，没有裸名。
+	catalog := map[string]string{
+		"gemini-3.8-flash-low":    "gemini-3.8-flash-low",
+		"gemini-3.8-flash-medium": "gemini-3.8-flash-medium",
+		"gemini-3.8-flash-high":   "gemini-3.8-flash-high",
+		"gemini-3.8-flash-tiered": "gemini-3.8-flash-tiered",
+		"gemini-3.6-flash-high":   "gemini-3.6-flash-high",
+		"gemini-3.1-pro-high":     "gemini-3.1-pro-high",
+		"gemini-2.5-flash":        "gemini-2.5-flash",
+	}
+	budget := func(v string) []byte {
+		return []byte(`{"contents":[],"generationConfig":{"thinkingConfig":{"thinkingBudget":` + v + `}}}`)
+	}
+
+	tests := []struct {
+		name      string
+		mapping   map[string]string
+		model     string
+		body      []byte
+		want      string
+		wantMatch bool
+	}{
+		{"agy high (-1) -> -high", catalog, "gemini-3.8-flash", budget("-1"), "gemini-3.8-flash-high", true},
+		{"agy medium (4000) -> -medium", catalog, "gemini-3.8-flash", budget("4000"), "gemini-3.8-flash-medium", true},
+		{"agy low (1000) -> -low", catalog, "gemini-3.8-flash", budget("1000"), "gemini-3.8-flash-low", true},
+		{"models/ prefix stripped", catalog, "models/gemini-3.8-flash", budget("1000"), "gemini-3.8-flash-low", true},
+		{"no thinkingConfig -> -high", catalog, "gemini-3.8-flash", []byte(`{"contents":[]}`), "gemini-3.8-flash-high", true},
+		// gemini-3.6/3.7/3.8-flash 的四个变体会被 resolveModelMapping 自动补齐，所以降级用一个不在默认表里的型号
+		{"only -high exists: low request degrades to high", map[string]string{
+			"gemini-3.5-flash-high": "gemini-3.5-flash-high",
+		}, "gemini-3.5-flash", budget("1000"), "gemini-3.5-flash-high", true},
+		{"injected default variants are usable", catalog, "gemini-3.6-flash", budget("1000"), "gemini-3.6-flash-low", true},
+		{"already suffixed: untouched", catalog, "gemini-3.8-flash-low", budget("-1"), "", false},
+		{"bare name explicitly mapped: untouched", catalog, "gemini-2.5-flash", budget("-1"), "", false},
+		{"no variants in mapping: untouched", catalog, "gemini-9.9-flash", budget("-1"), "", false},
+		{"non-gemini model: untouched", catalog, "claude-sonnet-4-6", budget("-1"), "", false},
+		{"explicit bare alias wins over variants", map[string]string{
+			"gemini-3.8-flash":      "gemini-3.8-flash-tiered",
+			"gemini-3.8-flash-high": "gemini-3.8-flash-high",
+		}, "gemini-3.8-flash", budget("-1"), "", false},
+		{"variant value is itself a mapping target", map[string]string{
+			"gemini-3.8-flash-high": "gemini-3.8-flash-tiered",
+		}, "gemini-3.8-flash", budget("-1"), "gemini-3.8-flash-tiered", true},
+		{"user-written bare identity passthrough: respected", map[string]string{
+			"gemini-3.8-flash":      "gemini-3.8-flash",
+			"gemini-3.8-flash-high": "gemini-3.8-flash-high",
+		}, "gemini-3.8-flash", budget("1000"), "", false},
+		{"runtime-injected bare passthrough (not in credentials): still resolved", map[string]string{
+			// resolveModelMapping 会补 gemini-3.7-flash → gemini-3.7-flash 的默认透传，
+			// 但 credentials 里没有这条，应当继续推导变体。
+			"gemini-3.7-flash-medium": "gemini-3.7-flash-medium",
+		}, "gemini-3.7-flash", budget("4000"), "gemini-3.7-flash-medium", true},
+		// 空 credentials 映射 → 走 DefaultAntigravityModelMapping，其中同样只有带后缀的 3.8 flash
+		{"empty mapping falls back to default catalog", map[string]string{}, "gemini-3.8-flash", budget("-1"), "gemini-3.8-flash-high", true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			account := newAntigravityAccountWithMapping(tt.mapping)
+			got, matched := resolveGeminiThinkingVariant(account, tt.model, tt.body)
+			require.Equal(t, tt.wantMatch, matched)
+			require.Equal(t, tt.want, got)
+		})
+	}
+
+	t.Run("nil account", func(t *testing.T) {
+		got, matched := resolveGeminiThinkingVariant(nil, "gemini-3.8-flash", budget("-1"))
+		require.False(t, matched)
+		require.Empty(t, got)
+	})
+}