fix(gemini): INVALID_ARGUMENT when loaded too many MCPs

Author: edelauna

apps/vscode-e2e/src/suite/providers/gemini.test.ts

@@ -8,12 +8,68 @@ import { waitUntilCompleted } from "../utils"
 const GEMINI_API_KEY = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY
 const GEMINI_MODEL_ID = "gemini-3.1-pro-preview"
 
+type FunctionDeclaration = {
+	name: string
+	parametersJsonSchema?: Record<string, unknown>
+}
+
+type GeminiToolConfig = {
+	functionCallingConfig?: {
+		mode?: string
+		allowedFunctionNames?: string[]
+	}
+}
+
 type CapturedGeminiRequest = {
 	model?: string
 	lastUserMessage: string
 	thinkingConfig?: Record<string, unknown>
+	toolConfig?: GeminiToolConfig
 	hasTools: boolean
 	toolDeclarationCount: number
+	functionDeclarations: FunctionDeclaration[]
+}
+
+function findInvalidSchemaPatterns(schema: unknown, path = ""): string[] {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+		return []
+	}
+
+	const obj = schema as Record<string, unknown>
+	const violations: string[] = []
+
+	if ("additionalProperties" in obj) {
+		violations.push(`${path}.additionalProperties (stripped for Gemini compatibility)`)
+	}
+
+	if ("default" in obj) {
+		violations.push(`${path}.default (stripped for Gemini compatibility)`)
+	}
+
+	if ("$schema" in obj) {
+		violations.push(`${path}.$schema (JSON Schema metadata stripped for Gemini compatibility)`)
+	}
+
+	if ("type" in obj && Array.isArray(obj.type)) {
+		violations.push(`${path}.type is an array ${JSON.stringify(obj.type)} (Gemini requires a single string type)`)
+	}
+
+	for (const [key, value] of Object.entries(obj)) {
+		if (key === "properties" && value && typeof value === "object") {
+			for (const [propName, propSchema] of Object.entries(value as Record<string, unknown>)) {
+				violations.push(...findInvalidSchemaPatterns(propSchema, `${path}.properties.${propName}`))
+			}
+		} else if (key === "items") {
+			violations.push(...findInvalidSchemaPatterns(value, `${path}.items`))
+		} else if (key === "anyOf" || key === "oneOf" || key === "allOf") {
+			violations.push(`${path}.${key} (collapsed for Gemini compatibility)`)
+			if (Array.isArray(value)) {
+				value.forEach((item, i) => violations.push(...findInvalidSchemaPatterns(item, `${path}.${key}[${i}]`)))
+			}
+		}
+	}
+
+	return violations
 }
 
 function getRequestUrl(input: RequestInfo | URL): string {
@@ -74,9 +130,10 @@ function installGeminiRequestCapture(capture: CapturedGeminiRequest[], baseUrl:
 		if (isUrlWithOrigin(url, targetOrigin) && isGeminiGenerateContentUrl(url)) {
 			const body = init?.body && typeof init.body === "string" ? JSON.parse(init.body) : {}
 			const tools = Array.isArray(body.tools) ? body.tools : []
-			const toolDeclarationCount = tools.reduce((count: number, tool: { functionDeclarations?: unknown[] }) => {
-				return count + (Array.isArray(tool.functionDeclarations) ? tool.functionDeclarations.length : 0)
-			}, 0)
+			const functionDeclarations: FunctionDeclaration[] = tools.flatMap(
+				(tool: { functionDeclarations?: FunctionDeclaration[] }) =>
+					Array.isArray(tool.functionDeclarations) ? tool.functionDeclarations : [],
+			)
 
 			capture.push({
 				model: extractGeminiModel(url),
@@ -85,8 +142,13 @@ function installGeminiRequestCapture(capture: CapturedGeminiRequest[], baseUrl:
 					body.generationConfig && typeof body.generationConfig === "object"
 						? (body.generationConfig.thinkingConfig as Record<string, unknown> | undefined)
 						: undefined,
+				toolConfig:
+					body.toolConfig && typeof body.toolConfig === "object"
+						? (body.toolConfig as GeminiToolConfig)
+						: undefined,
 				hasTools: tools.length > 0,
-				toolDeclarationCount,
+				toolDeclarationCount: functionDeclarations.length,
+				functionDeclarations,
 			})
 		}
 
@@ -105,7 +167,8 @@ suite("Gemini provider", function () {
 	const requests: CapturedGeminiRequest[] = []
 
 	setup(function () {
-		if (!process.env.AIMOCK_URL && !GEMINI_API_KEY) {
+		const isReplay = process.env.AIMOCK_URL && process.env.AIMOCK_RECORD !== "true"
+		if (!isReplay && !GEMINI_API_KEY) {
 			this.skip()
 		}
 	})
@@ -131,23 +194,21 @@ suite("Gemini provider", function () {
 		})
 	})
 
-	for (const reasoningEnabled of [true, false] as const) {
-		test(`Should complete a task end-to-end using ${GEMINI_MODEL_ID} via Gemini provider with reasoning ${
-			reasoningEnabled ? "enabled" : "disabled"
-		}`, async () => {
+	for (const reasoningEffort of ["high", "low", "disable"] as const) {
+		test(`Should complete a task end-to-end using ${GEMINI_MODEL_ID} via Gemini provider with reasoning effort "${reasoningEffort}"`, async () => {
 			requests.length = 0
 
 			const api = globalThis.api
 			const aimockUrl = process.env.AIMOCK_URL
 			const isRecord = process.env.AIMOCK_RECORD === "true"
-			const promptTag = reasoningEnabled ? "gemini-e2e:reasoning-on" : "gemini-e2e:reasoning-off"
+			const promptTag = `gemini-e2e:reasoning-${reasoningEffort}`
 
 			await api.setConfiguration({
 				apiProvider: "gemini" as const,
 				geminiApiKey: aimockUrl && !isRecord ? "mock-key" : GEMINI_API_KEY!,
 				apiModelId: GEMINI_MODEL_ID,
-				enableReasoningEffort: reasoningEnabled,
-				reasoningEffort: reasoningEnabled ? ("high" as const) : ("disable" as const),
+				enableReasoningEffort: reasoningEffort !== "disable",
+				reasoningEffort: reasoningEffort,
 				...(aimockUrl && { googleGeminiBaseUrl: aimockUrl }),
 			})
 
@@ -179,18 +240,39 @@ suite("Gemini provider", function () {
 				firstRequest.toolDeclarationCount > 0,
 				"Gemini provider should declare at least one callable tool",
 			)
+			assert.strictEqual(
+				firstRequest.toolConfig?.functionCallingConfig?.allowedFunctionNames,
+				undefined,
+				"Gemini requests should not send allowedFunctionNames; the Gemini backend returns generic INVALID_ARGUMENT for larger or history-incompatible restriction lists",
+			)
 
-			if (reasoningEnabled) {
-				assert.ok(
-					firstRequest.thinkingConfig,
-					"Reasoning-enabled Gemini requests should include thinkingConfig",
+			// Verify tool schemas are sanitized for Gemini compatibility. Gemini documents
+			// function declaration schemas as a selected OpenAPI-style subset with
+			// single-value `type` plus `nullable`; live testing also showed opaque
+			// INVALID_ARGUMENT failures from broader third-party MCP schema metadata.
+			for (const decl of firstRequest.functionDeclarations) {
+				const violations = findInvalidSchemaPatterns(
+					decl.parametersJsonSchema,
+					`${decl.name}.parametersJsonSchema`,
 				)
-			} else {
+				assert.strictEqual(
+					violations.length,
+					0,
+					`Tool "${decl.name}" has Gemini-incompatible schema: ${violations.join("; ")}`,
+				)
+			}
+
+			if (reasoningEffort === "disable") {
 				assert.strictEqual(
 					firstRequest.thinkingConfig,
 					undefined,
 					"Reasoning-disabled Gemini requests should omit thinkingConfig",
 				)
+			} else {
+				assert.ok(
+					firstRequest.thinkingConfig,
+					`Gemini requests with reasoningEffort="${reasoningEffort}" should include thinkingConfig`,
+				)
 			}
 
 			const completionMessage = messages.find(

package.json

@@ -21,6 +21,7 @@
 		"vsix:nightly": "turbo vsix:nightly --log-order grouped --output-logs new-only",
 		"clean": "turbo clean --log-order grouped --output-logs new-only && rimraf dist out bin .vite-port .turbo",
 		"install:vsix": "pnpm install --frozen-lockfile && pnpm clean && pnpm vsix && node scripts/install-vsix.js",
+		"install:vsix:force": "pnpm install --frozen-lockfile && pnpm clean && turbo bundle --force && turbo vsix --force && node scripts/install-vsix.js",
 		"install:vsix:nightly": "pnpm install --frozen-lockfile && pnpm clean && pnpm vsix:nightly && node scripts/install-vsix.js --nightly",
 		"code-server:install": "node scripts/code-server.js",
 		"changeset:version": "cp CHANGELOG.md src/CHANGELOG.md && changeset version && cp -vf src/CHANGELOG.md .",