@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/gemini.js

@@ -1,6 +1,7 @@
-import { extractOverrides, flattenHeaders, formatToMime, getContext, getTestId, isAudioResponse, isContentWithToolCallsResponse, isErrorResponse, isJsonObject, isTextResponse, isToolCallResponse, resolveFixtureBlockOutcome, resolveReasoningForModel, resolveResponse, resolveStrictMode, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField, validateToolsField } from "./helpers.js";
+import { extractOverrides, flattenHeaders, formatToMime, getContext, getTestId, isAudioResponse, isCombinedFixtureResponse, isErrorResponse, isJsonObject, isTextResponse, isToolCallResponse, requireEmittedFunctionToolCalls, requireServedFunctionToolCalls, resolveFixtureBlockOutcome, resolveReasoningForModel, resolveResponse, resolveStrictMode, resolveUsage, servedToolArgs, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField, validateToolsField } from "./helpers.js";
 import { calculateDelay, delay, writeErrorResponse } from "./sse-writer.js";
 import { applyChaosAsync } from "./chaos.js";
+import { planMisbehavior, recordMisbehaviorOutcome } from "./misbehavior.js";
 import { matchFixtureDiagnostic, recordMatchOptions } from "./router.js";
 import { proxyAndRecord } from "./recorder.js";
 import { createInterruptionSignal } from "./interruption.js";
@@ -29,7 +30,14 @@ function validateGeminiBody(req) {
 		const parts = req.systemInstruction.parts;
 		if (parts !== void 0 && parts !== null && !Array.isArray(parts)) return "systemInstruction.parts must be an array";
 	}
-	return validateToolsField(req.tools);
+	const toolsError = validateToolsField(req.tools);
+	if (toolsError) return toolsError;
+	if (Array.isArray(req.tools)) for (const [toolIndex, tool] of req.tools.entries()) {
+		if (!Array.isArray(tool.functionDeclarations)) continue;
+		const declarationIndex = tool.functionDeclarations.findIndex((declaration) => declaration === null);
+		if (declarationIndex !== -1) return `tools[${toolIndex}].functionDeclarations[${declarationIndex}] must not be null`;
+	}
+	return null;
 }
 function geminiToCompletionRequest(req, model, stream) {
 	const messages = [];
@@ -108,7 +116,7 @@ function geminiToCompletionRequest(req, model, stream) {
 			function: {
 				name: d.name,
 				description: d.description,
-				parameters: d.parameters
+				parameters: d.parameters ?? d.parametersJsonSchema
 			}
 		}));
 	}
@@ -192,16 +200,10 @@ function buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) {
 	return chunks;
 }
 function parseToolCallPart(tc, logger) {
-	let argsObj;
-	try {
-		argsObj = JSON.parse(tc.arguments || "{}");
-	} catch {
-		logger.warn(`Malformed JSON in fixture tool call arguments for "${tc.name}": ${tc.arguments}`);
-		argsObj = {};
-	}
+	const args = servedToolArgs(tc, "object", logger);
 	const functionCall = {
 		name: tc.name,
-		args: argsObj
+		args: args.value
 	};
 	if (tc.id) functionCall.id = tc.id;
 	return { functionCall };
@@ -418,24 +420,24 @@ function resolveAudioInlineData(audio) {
 		data: audio.audio.b64Json
 	};
 }
-function buildGeminiAudioParts(audio, logger, effReasoning) {
+function buildGeminiAudioParts(audio, toolCalls, logger, effReasoning) {
 	const parts = [{ inlineData: resolveAudioInlineData(audio) }];
 	if (effReasoning) parts.push({
 		text: effReasoning,
 		thought: true
 	});
 	if (audio.content) parts.push({ text: audio.content });
-	if (audio.toolCalls?.length) parts.push(...audio.toolCalls.map((tc) => parseToolCallPart(tc, logger)));
+	if (toolCalls.length) parts.push(...toolCalls.map((tc) => parseToolCallPart(tc, logger)));
 	return parts;
 }
-function buildGeminiAudioResponse(audio, logger, effReasoning) {
+function buildGeminiAudioResponse(audio, toolCalls, logger, effReasoning) {
 	return {
 		candidates: [{
 			content: {
 				role: "model",
-				parts: buildGeminiAudioParts(audio, logger, effReasoning)
+				parts: buildGeminiAudioParts(audio, toolCalls, logger, effReasoning)
 			},
-			finishReason: audio.toolCalls?.length ? "FUNCTION_CALL" : "STOP",
+			finishReason: toolCalls.length ? "FUNCTION_CALL" : "STOP",
 			index: 0
 		}],
 		usageMetadata: {
@@ -445,14 +447,14 @@ function buildGeminiAudioResponse(audio, logger, effReasoning) {
 		}
 	};
 }
-function buildGeminiAudioStreamChunks(audio, logger, effReasoning) {
+function buildGeminiAudioStreamChunks(audio, toolCalls, logger, effReasoning) {
 	return [{
 		candidates: [{
 			content: {
 				role: "model",
-				parts: buildGeminiAudioParts(audio, logger, effReasoning)
+				parts: buildGeminiAudioParts(audio, toolCalls, logger, effReasoning)
 			},
-			finishReason: audio.toolCalls?.length ? "FUNCTION_CALL" : "STOP",
+			finishReason: toolCalls.length ? "FUNCTION_CALL" : "STOP",
 			index: 0
 		}],
 		usageMetadata: {
@@ -487,8 +489,90 @@ async function writeGeminiSSEStream(res, chunks, optionsOrLatency) {
 	if (!res.writableEnded) res.end();
 	return true;
 }
+/** Prepare native fault output once; the journal describes these exact parts. */
+function prepareGeminiMisbehavior(plan, request, streaming, chunkSize, logger, strict) {
+	const response = plan.response;
+	const combined = isCombinedFixtureResponse(response);
+	if (!(combined || isToolCallResponse(response) || isTextResponse(response))) throw new Error("Applied Gemini misbehavior requires a chat response");
+	const outcome = combined && response.blocks?.length ? resolveFixtureBlockOutcome(response.blocks) : void 0;
+	const content = outcome?.content ?? ("content" in response ? response.content ?? "" : "");
+	const calls = outcome?.toolCalls ?? ("toolCalls" in response ? response.toolCalls ?? [] : []);
+	const overrides = extractOverrides(response);
+	delete overrides.usage;
+	const fault = plan.summary.fault;
+	const candidate = {
+		content: {
+			role: "model",
+			parts: []
+		},
+		index: 0
+	};
+	let chunks;
+	if (fault === "tool-args-invalid-json") {
+		const target = calls[plan.target?.index ?? 0];
+		if (!target) throw new Error("Gemini malformed-call plan requires its selected tool call");
+		chunks = [{ candidates: [{
+			index: 0,
+			finishReason: "MALFORMED_FUNCTION_CALL",
+			finishMessage: `Malformed function call: ${target.name}(${target.arguments})`
+		}] }];
+	} else if (fault === "tool-unknown-name" && !request.tools?.length) {
+		candidate.finishReason = "UNEXPECTED_TOOL_CALL";
+		chunks = [{ candidates: [candidate] }];
+	} else if (fault === "stop-length-mid-tool") {
+		candidate.content.parts = content ? [{ text: content }] : [];
+		candidate.finishReason = "MAX_TOKENS";
+		chunks = [{ candidates: [candidate] }];
+	} else if (fault === "empty-response") {
+		candidate.content.parts = [{ text: "" }];
+		candidate.finishReason = "STOP";
+		chunks = [{ candidates: [candidate] }];
+	} else if (fault === "content-filter") {
+		candidate.finishReason = "SAFETY";
+		candidate.safetyRatings = [{
+			category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+			probability: "HIGH",
+			blocked: true
+		}];
+		chunks = [{ candidates: [candidate] }];
+	} else if (fault === "reasoning-only") {
+		candidate.content.parts = [{
+			text: plan.reasoning ?? "",
+			thought: true
+		}];
+		candidate.finishReason = "MAX_TOKENS";
+		chunks = [{ candidates: [candidate] }];
+	} else {
+		const reasoning = resolveReasoningForModel(response.reasoning, request.model, strict, logger);
+		if (fault === "tool-unknown-name") overrides.finishReason = "stop";
+		if (combined) chunks = streaming ? buildGeminiContentWithToolCallsStreamChunks(content, calls, chunkSize, logger, reasoning, overrides, response.blocks) : [buildGeminiContentWithToolCallsResponse(content, calls, logger, reasoning, overrides, response.blocks)];
+		else if (isToolCallResponse(response)) chunks = streaming ? buildGeminiToolCallStreamChunks(calls, chunkSize, logger, reasoning, overrides) : [buildGeminiToolCallResponse(calls, logger, reasoning, overrides)];
+		else chunks = streaming ? buildGeminiTextStreamChunks(content, chunkSize, reasoning, overrides) : [buildGeminiTextResponse(content, reasoning, overrides)];
+	}
+	const parts = chunks.flatMap((chunk) => chunk.candidates.flatMap((item) => item.content?.parts ?? []));
+	const servedToolCalls = parts.flatMap((part) => part.functionCall ? [{
+		name: part.functionCall.name,
+		arguments: JSON.stringify(part.functionCall.args),
+		...part.functionCall.id ? { id: part.functionCall.id } : {}
+	}] : []);
+	const usage = resolveUsage(void 0, request.messages.map((message) => typeof message.content === "string" ? message.content : (message.content ?? []).map((part) => part.text ?? "").join("")).join(""), parts.map((part) => part.text ?? (part.functionCall ? part.functionCall.name + JSON.stringify(part.functionCall.args) : "")).join(""));
+	for (const chunk of chunks) delete chunk.usageMetadata;
+	chunks[chunks.length - 1].usageMetadata = {
+		promptTokenCount: usage.prompt_tokens,
+		candidatesTokenCount: usage.completion_tokens,
+		totalTokenCount: usage.total_tokens
+	};
+	return {
+		chunks,
+		summary: {
+			...plan.summary,
+			servedToolCalls
+		}
+	};
+}
 async function handleGemini(req, res, raw, model, streaming, fixtures, journal, defaults, setCorsHeaders, providerKey = "gemini") {
 	const { logger } = defaults;
+	const wire = providerKey === "vertexai" ? "Vertex AI" : "Gemini";
 	setCorsHeaders(res);
 	let geminiReq;
 	try {
@@ -623,21 +707,101 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 		return;
 	}
 	const response = await resolveResponse(fixture, completionReq);
+	const misbehavior = planMisbehavior({
+		wire: "gemini",
+		toolCallIdMode: "authored-nonempty",
+		fixture,
+		response,
+		request: completionReq,
+		stream: streaming,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path,
+				headers: flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture,
+					error: misbehavior.message
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		if (misbehavior.summary?.evaluations.length === 0) logger.error(`${req.method ?? "POST"} ${path}: ${misbehavior.message}`);
+		writeErrorResponse(res, misbehavior.status, JSON.stringify({ error: {
+			code: misbehavior.status,
+			message: misbehavior.message,
+			status: misbehavior.status === 400 ? "INVALID_ARGUMENT" : "UNIMPLEMENTED"
+		} }));
+		return;
+	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
-	if (isErrorResponse(response)) {
-		const status = response.status ?? 500;
-		journal.add({
+	if (misbehavior.kind === "applied") {
+		const prepared = prepareGeminiMisbehavior(misbehavior, completionReq, streaming, chunkSize, logger, resolveStrictMode(defaults.strict, req.headers));
+		const entry = journal.add({
 			method: req.method ?? "POST",
 			path,
 			headers: flattenHeaders(req.headers),
 			body: completionReq,
 			response: {
-				status,
+				status: 200,
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry,
+			summary: prepared.summary,
+			defaults,
+			testId
+		});
+		if (!streaming) {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(prepared.chunks[0]));
+		} else {
+			const interruption = createInterruptionSignal(fixture);
+			if (!await writeGeminiSSEStream(res, prepared.chunks, {
+				latency,
+				streamingProfile: fixture.streamingProfile,
+				recordedTimings: fixture.recordedTimings,
+				replaySpeed,
+				signal: interruption?.signal,
+				onChunkSent: interruption?.tick
+			})) {
+				if (!res.writableEnded) res.destroy();
+				entry.response.interrupted = true;
+				entry.response.interruptReason = interruption?.reason();
+			}
+			interruption?.cleanup();
+		}
+		return;
+	}
+	if (isErrorResponse(response)) {
+		const status = response.status ?? 500;
+		recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path,
+				headers: flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		const geminiError = { error: {
 			code: status,
 			message: response.error.message,
@@ -659,12 +823,19 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const audioToolCalls = Array.isArray(response.toolCalls) ? requireServedFunctionToolCalls(response, wire) : [];
 		if (!streaming) {
-			const body = buildGeminiAudioResponse(response, logger, effReasoning);
+			const body = buildGeminiAudioResponse(response, audioToolCalls, logger, effReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const chunks = buildGeminiAudioStreamChunks(response, logger, effReasoning);
+			const chunks = buildGeminiAudioStreamChunks(response, audioToolCalls, logger, effReasoning);
 			const interruption = createInterruptionSignal(fixture);
 			if (!await writeGeminiSSEStream(res, chunks, {
 				latency,
@@ -682,7 +853,7 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 		}
 		return;
 	}
-	if (isContentWithToolCallsResponse(response)) {
+	if (isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini API — ignoring");
 		const overrides = extractOverrides(response);
 		const effectiveStrict = resolveStrictMode(defaults.strict, req.headers);
@@ -697,12 +868,19 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = requireEmittedFunctionToolCalls(response, wire);
 		if (!streaming) {
-			const body = buildGeminiContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], logger, effReasoning, overrides, response.blocks);
+			const body = buildGeminiContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const chunks = buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", response.toolCalls ?? [], chunkSize, logger, effReasoning, overrides, response.blocks);
+			const chunks = buildGeminiContentWithToolCallsStreamChunks(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks);
 			const interruption = createInterruptionSignal(fixture);
 			if (!await writeGeminiSSEStream(res, chunks, {
 				latency,
@@ -735,6 +913,12 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		if (!streaming) {
 			const body = buildGeminiTextResponse(response.content, effReasoning, overrides);
 			res.writeHead(200, { "Content-Type": "application/json" });
@@ -773,12 +957,19 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = requireEmittedFunctionToolCalls(response, wire);
 		if (!streaming) {
-			const body = buildGeminiToolCallResponse(response.toolCalls, logger, effReasoning, overrides);
+			const body = buildGeminiToolCallResponse(functionToolCalls, logger, effReasoning, overrides);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const chunks = buildGeminiToolCallStreamChunks(response.toolCalls, chunkSize, logger, effReasoning, overrides);
+			const chunks = buildGeminiToolCallStreamChunks(functionToolCalls, chunkSize, logger, effReasoning, overrides);
 			const interruption = createInterruptionSignal(fixture);
 			if (!await writeGeminiSSEStream(res, chunks, {
 				latency,
@@ -796,15 +987,20 @@ async function handleGemini(req, res, raw, model, streaming, fixtures, journal,
 		}
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path,
-		headers: flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path,
+			headers: flattenHeaders(req.headers),
+			body: completionReq,
+			response: {
+				status: 500,
+				fixture
+			}
+		}),
+		summary: misbehavior.summary,
+		defaults,
+		testId
 	});
 	writeErrorResponse(res, 500, JSON.stringify({ error: {
 		message: "Fixture response did not match any known type",