fix: preserve top-level Gemini schema fields with allOf

Author: roomote

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

@@ -587,5 +587,47 @@ describe("GeminiHandler backend support", () => {
 			})
 			expect(schema.properties.name).toEqual({ type: "string" })
 		})
+
+		it("should preserve top-level properties and required entries when allOf is also present", 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: "mixed_allof_tool",
+								description: "Tool with top-level and allOf schema fragments",
+								parameters: {
+									type: "object",
+									properties: { a: { type: "string" } },
+									required: ["a"],
+									allOf: [
+										{
+											type: "object",
+											properties: { b: { type: "integer" } },
+											required: ["b"],
+										},
+									],
+								},
+							},
+						},
+					],
+				})
+				.next()
+
+			const schema = stub.mock.calls[0][0].config.tools[0].functionDeclarations[0].parametersJsonSchema
+			expect(schema.properties).toEqual({
+				a: { type: "string" },
+				b: { type: "integer" },
+			})
+			expect(schema.required).toEqual(expect.arrayContaining(["a", "b"]))
+		})
 	})
 })

src/api/providers/gemini.ts

@@ -115,6 +115,25 @@ function sanitizeSchemaForGemini(schema: unknown, defs?: Record<string, unknown>
 			continue
 		}
 
+		if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+			const sanitizedProperties = sanitizeSchemaForGemini(value, resolvedDefs)
+			if (sanitizedProperties && typeof sanitizedProperties === "object" && !Array.isArray(sanitizedProperties)) {
+				result.properties = {
+					...(result.properties as Record<string, unknown> | undefined),
+					...(sanitizedProperties as Record<string, unknown>),
+				}
+			}
+			continue
+		}
+
+		if (key === "required" && Array.isArray(value)) {
+			const existing = Array.isArray(result.required) ? (result.required as string[]) : []
+			result.required = [
+				...new Set([...existing, ...value.filter((item): item is string => typeof item === "string")]),
+			]
+			continue
+		}
+
 		if (key === "type" && Array.isArray(value)) {
 			const nonNullTypes = value.filter((item) => item !== "null")
 			if (nonNullTypes.length > 0) {