fix(gemini): resolve $ref, deep-merge allOf, align e2e fixtures

Author: edelauna

apps/vscode-e2e/fixtures/gemini.json

@@ -3,29 +3,44 @@
 		{
 			"match": {
 				"model": "gemini-3.1-pro-preview",
-				"userMessage": "gemini-e2e:reasoning-on: what is 2+2? Reply with only the number."
+				"userMessage": "gemini-e2e:reasoning-high: what is 2+2? Reply with only the number."
 			},
 			"response": {
 				"toolCalls": [
 					{
 						"name": "attempt_completion",
 						"arguments": "{\"result\":\"4\"}",
-						"id": "call_gemini_reasoning_on_done"
+						"id": "call_gemini_reasoning_high_done"
 					}
 				]
 			}
 		},
 		{
 			"match": {
 				"model": "gemini-3.1-pro-preview",
-				"userMessage": "gemini-e2e:reasoning-off: what is 2+2? Reply with only the number."
+				"userMessage": "gemini-e2e:reasoning-low: what is 2+2? Reply with only the number."
 			},
 			"response": {
 				"toolCalls": [
 					{
 						"name": "attempt_completion",
 						"arguments": "{\"result\":\"4\"}",
-						"id": "call_gemini_reasoning_off_done"
+						"id": "call_gemini_reasoning_low_done"
+					}
+				]
+			}
+		},
+		{
+			"match": {
+				"model": "gemini-3.1-pro-preview",
+				"userMessage": "gemini-e2e:reasoning-disable: what is 2+2? Reply with only the number."
+			},
+			"response": {
+				"toolCalls": [
+					{
+						"name": "attempt_completion",
+						"arguments": "{\"result\":\"4\"}",
+						"id": "call_gemini_reasoning_disable_done"
 					}
 				]
 			}

src/api/providers/__tests__/gemini-handler.spec.ts

@@ -493,5 +493,99 @@ describe("GeminiHandler backend support", () => {
 				},
 			})
 		})
+
+		it("should deep-merge allOf fragments instead of overwriting earlier properties", async () => {
+			const options = { apiProvider: "gemini" } as ApiHandlerOptions
+			const handler = new GeminiHandler(options)
+			const stub = vi.fn().mockReturnValue((async function* () {})())
+			// @ts-ignore access private client
+			handler["client"].models.generateContentStream = stub
+
+			await handler
+				.createMessage("test", [] as any, {
+					taskId: "test-task",
+					tools: [
+						{
+							type: "function",
+							function: {
+								name: "multi_allof_tool",
+								description: "Tool with multi-fragment allOf",
+								parameters: {
+									allOf: [
+										{
+											type: "object",
+											properties: { a: { type: "string" } },
+											required: ["a"],
+										},
+										{
+											type: "object",
+											properties: { b: { type: "integer" } },
+											required: ["b"],
+										},
+									],
+								},
+							},
+						},
+					],
+				})
+				.next()
+
+			const schema = stub.mock.calls[0][0].config.tools[0].functionDeclarations[0].parametersJsonSchema
+			// Both property blocks must survive the merge — previously `b` overwrote `a`
+			expect(schema.properties).toEqual({
+				a: { type: "string" },
+				b: { type: "integer" },
+			})
+			expect(schema.required).toEqual(expect.arrayContaining(["a", "b"]))
+		})
+
+		it("should resolve $ref entries before dropping $defs", async () => {
+			const options = { apiProvider: "gemini" } as ApiHandlerOptions
+			const handler = new GeminiHandler(options)
+			const stub = vi.fn().mockReturnValue((async function* () {})())
+			// @ts-ignore access private client
+			handler["client"].models.generateContentStream = stub
+
+			await handler
+				.createMessage("test", [] as any, {
+					taskId: "test-task",
+					tools: [
+						{
+							type: "function",
+							function: {
+								name: "ref_tool",
+								description: "Tool with $ref",
+								parameters: {
+									type: "object",
+									$defs: {
+										Config: {
+											type: "object",
+											properties: { timeout: { type: "integer" } },
+											required: ["timeout"],
+										},
+									},
+									properties: {
+										cfg: { $ref: "#/$defs/Config" },
+										name: { type: "string" },
+									},
+									required: ["cfg", "name"],
+								},
+							},
+						},
+					],
+				})
+				.next()
+
+			const schema = stub.mock.calls[0][0].config.tools[0].functionDeclarations[0].parametersJsonSchema
+			// $defs must be gone, $ref must be inlined
+			expect(JSON.stringify(schema)).not.toContain("$defs")
+			expect(JSON.stringify(schema)).not.toContain("$ref")
+			expect(schema.properties.cfg).toEqual({
+				type: "object",
+				properties: { timeout: { type: "integer" } },
+				required: ["timeout"],
+			})
+			expect(schema.properties.name).toEqual({ type: "string" })
+		})
 	})
 })

src/api/providers/gemini.ts

@@ -46,16 +46,33 @@ const GEMINI_SCHEMA_COMPATIBILITY_DROP_KEYS = new Set([
 	"definitions",
 ])
 
-function sanitizeSchemaForGemini(schema: unknown): unknown {
+function sanitizeSchemaForGemini(schema: unknown, defs?: Record<string, unknown>): unknown {
 	if (!schema || typeof schema !== "object") {
 		return schema
 	}
 
 	if (Array.isArray(schema)) {
-		return schema.map((item) => sanitizeSchemaForGemini(item))
+		return schema.map((item) => sanitizeSchemaForGemini(item, defs))
 	}
 
 	const source = schema as Record<string, unknown>
+
+	// Extract $defs / definitions from the root schema on the first call so
+	// they can be used to resolve $ref entries encountered deeper in the tree.
+	const resolvedDefs = defs ?? ((source.$defs ?? source.definitions) as Record<string, unknown> | undefined)
+
+	// Resolve local JSON Pointer $ref before any other processing.
+	// Without this, dropping $defs leaves dangling references that Gemini rejects.
+	if (typeof source.$ref === "string" && resolvedDefs) {
+		const match = source.$ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/)
+		if (match) {
+			const resolved = resolvedDefs[match[1]]
+			if (resolved !== undefined) {
+				return sanitizeSchemaForGemini(resolved, resolvedDefs)
+			}
+		}
+	}
+
 	const result: Record<string, unknown> = {}
 	let nullable = source.nullable === true
 
@@ -67,14 +84,28 @@ function sanitizeSchemaForGemini(schema: unknown): unknown {
 				: true
 		})
 		nullable = nullable || variants.length < composition.length
-		Object.assign(result, sanitizeSchemaForGemini(variants[0] ?? {}))
+		Object.assign(result, sanitizeSchemaForGemini(variants[0] ?? {}, resolvedDefs))
 	}
 
 	if (Array.isArray(source.allOf)) {
 		for (const variant of source.allOf) {
-			const sanitized = sanitizeSchemaForGemini(variant)
+			const sanitized = sanitizeSchemaForGemini(variant, resolvedDefs)
 			if (sanitized && typeof sanitized === "object" && !Array.isArray(sanitized)) {
-				Object.assign(result, sanitized)
+				const s = sanitized as Record<string, unknown>
+				// Deep-merge properties so later allOf fragments don't overwrite
+				// earlier ones (last-write-wins Object.assign drops prior keys).
+				if (s.properties && typeof s.properties === "object") {
+					result.properties = {
+						...(result.properties as Record<string, unknown> | undefined),
+						...(s.properties as Record<string, unknown>),
+					}
+				}
+				if (Array.isArray(s.required)) {
+					const existing = Array.isArray(result.required) ? (result.required as string[]) : []
+					result.required = [...new Set([...existing, ...(s.required as string[])])]
+				}
+				const { properties: _p, required: _r, ...rest } = s
+				Object.assign(result, rest)
 			}
 		}
 	}
@@ -93,7 +124,7 @@ function sanitizeSchemaForGemini(schema: unknown): unknown {
 			continue
 		}
 
-		result[key] = sanitizeSchemaForGemini(value)
+		result[key] = sanitizeSchemaForGemini(value, resolvedDefs)
 	}
 
 	if (nullable) {