@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/gemini-interactions.js

@@ -1,6 +1,7 @@
-import { extractOverrides, flattenHeaders, generateToolCallId, getContext, getTestId, isContentWithToolCallsResponse, isErrorResponse, isJsonObject, isTextResponse, isToolCallResponse, resolveFixtureBlockOutcome, resolveResponse, resolveStrictMode, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField } from "./helpers.js";
+import { extractOverrides, flattenHeaders, generateToolCallId, getContext, getTestId, isCombinedFixtureResponse, isErrorResponse, isJsonObject, isTextResponse, isToolCallResponse, prepareOpenAIChatMisbehavior, requireEmittedFunctionToolCalls, resolveFixtureBlockOutcome, resolveOpenAIChatMisbehaviorUsage, resolveResponse, resolveStrictMode, servedToolArgs, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField } from "./helpers.js";
 import { calculateDelay, delay, writeErrorResponse } from "./sse-writer.js";
 import { applyChaosAsync } from "./chaos.js";
+import { planMisbehavior, recordMisbehaviorOutcome } from "./misbehavior.js";
 import { matchFixtureDiagnostic } from "./router.js";
 import { proxyAndRecord } from "./recorder.js";
 import { createInterruptionSignal } from "./interruption.js";
@@ -22,6 +23,29 @@ const STEP_TYPES = new Set([
 	"model_output",
 	...STEP_RESULT_TYPES
 ]);
+function validateInteractionsInput(input) {
+	if (typeof input === "number") return "input must not be a number";
+	if (!Array.isArray(input)) return null;
+	const first = input[0];
+	if (isJsonObject(first) && "role" in first) for (const [index, turn] of input.entries()) {
+		if (!isJsonObject(turn)) continue;
+		const blocks = turn.content ?? turn.parts;
+		if (typeof blocks === "string" && blocks.length > 0) return `input[${index}].${turn.content != null ? "content" : "parts"} must be an array`;
+	}
+	else if (!(isJsonObject(first) && typeof first.type === "string" && STEP_TYPES.has(first.type))) {
+		const nullIndex = input.findIndex((part) => part === null);
+		if (nullIndex !== -1) return `input[${nullIndex}] must be an object`;
+	}
+	return null;
+}
+function validateInteractionsTools(tools) {
+	if (typeof tools === "string" && tools.length > 0) return "tools must be an array";
+	if (Array.isArray(tools)) {
+		const nullIndex = tools.findIndex((tool) => tool === null);
+		if (nullIndex !== -1) return `tools[${nullIndex}] must be an object`;
+	}
+	return null;
+}
 function geminiInteractionsToCompletionRequest(req) {
 	const messages = [];
 	const model = req.model ?? "gemini-2.5-flash";
@@ -192,18 +216,12 @@ function buildInteractionsTextResponse(content, model, interactionId, overrides)
 	};
 }
 function buildFunctionCallStep(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);
 	return {
 		type: "function_call",
 		id: tc.id || generateToolCallId(),
 		name: tc.name,
-		arguments: argsObj
+		arguments: args.value
 	};
 }
 function buildInteractionsToolCallResponse(toolCalls, model, interactionId, logger, overrides) {
@@ -337,13 +355,7 @@ function buildInteractionsToolCallSSEEvents(toolCalls, interactionId, logger, ov
 	});
 	for (let idx = 0; idx < toolCalls.length; idx++) {
 		const tc = toolCalls[idx];
-		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, "string", logger);
 		events.push({
 			event_type: "step.start",
 			index: idx,
@@ -360,7 +372,7 @@ function buildInteractionsToolCallSSEEvents(toolCalls, interactionId, logger, ov
 			index: idx,
 			delta: {
 				type: "arguments_delta",
-				arguments: JSON.stringify(argsObj)
+				arguments: args.text
 			},
 			event_id: nextEventId()
 		});
@@ -416,13 +428,7 @@ function pushTextStepEvents(events, index, content, chunkSize) {
 	});
 }
 function pushFunctionCallStepEvents(events, index, 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, "string", logger);
 	events.push({
 		event_type: "step.start",
 		index,
@@ -439,7 +445,7 @@ function pushFunctionCallStepEvents(events, index, tc, logger) {
 		index,
 		delta: {
 			type: "arguments_delta",
-			arguments: JSON.stringify(argsObj)
+			arguments: args.text
 		},
 		event_id: nextEventId()
 	});
@@ -516,6 +522,35 @@ async function writeGeminiInteractionsSSEStream(res, events, optionsOrLatency) {
 	if (!res.writableEnded) res.end();
 	return true;
 }
+function prepareInteractionsMisbehavior(plan, streaming) {
+	if (!streaming && plan.summary.fault === "stop-length-mid-tool") {
+		const response = plan.response;
+		const combined = isCombinedFixtureResponse(response);
+		const outcome = combined && response.blocks?.length ? resolveFixtureBlockOutcome(response.blocks) : void 0;
+		const toolCalls = (outcome?.toolCalls ?? (combined || isToolCallResponse(response) ? response.toolCalls ?? [] : [])).filter((_, index) => index !== plan.target?.index);
+		let callIndex = 0;
+		const blocks = outcome?.ordered.filter((block) => block.type === "text" || callIndex++ !== plan.target?.index);
+		plan = {
+			...plan,
+			response: {
+				...response,
+				toolCalls,
+				...blocks ? { blocks } : {}
+			}
+		};
+	}
+	return prepareOpenAIChatMisbehavior(plan);
+}
+function finalizeInteractionsMisbehavior(events, plan) {
+	if (plan.kind !== "applied" || plan.summary.fault !== "stop-length-mid-tool") return events;
+	return events.map((event) => event.event_type === "interaction.completed" && isJsonObject(event.interaction) ? {
+		...event,
+		interaction: {
+			...event.interaction,
+			status: "incomplete"
+		}
+	} : event);
+}
 async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaults, setCorsHeaders) {
 	const { logger } = defaults;
 	setCorsHeaders(res);
@@ -552,6 +587,21 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 		writeErrorResponse(res, 400, JSON.stringify(buildInteractionsErrorResponse("Request body must be a JSON object", "INVALID_ARGUMENT")));
 		return;
 	}
+	const validationError = validateInteractionsInput(interactionsReq.input) ?? validateInteractionsTools(interactionsReq.tools);
+	if (validationError) {
+		journal.add({
+			method: req.method ?? "POST",
+			path: urlPath,
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 400,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 400, JSON.stringify(buildInteractionsErrorResponse(validationError, "INVALID_ARGUMENT")));
+		return;
+	}
 	const completionReq = geminiInteractionsToCompletionRequest(interactionsReq);
 	completionReq._endpointType = "chat";
 	completionReq._context = getContext(req);
@@ -617,29 +667,172 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 		writeErrorResponse(res, 404, JSON.stringify(buildInteractionsErrorResponse("No fixture matched", "NOT_FOUND")));
 		return;
 	}
-	const response = await resolveResponse(fixture, completionReq);
+	let response = await resolveResponse(fixture, completionReq);
+	let misbehavior = planMisbehavior({
+		wire: "gemini-interactions",
+		fixture,
+		response,
+		request: completionReq,
+		stream: streaming,
+		emitsToolCallIds: true,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		if (!misbehavior.summary?.evaluations.some((evaluation) => evaluation.outcome === "error")) logger.error(`${req.method ?? "POST"} ${urlPath}: ${misbehavior.message}`);
+		writeErrorResponse(res, misbehavior.status, JSON.stringify(buildInteractionsErrorResponse(misbehavior.message, misbehavior.code)));
+		return;
+	}
+	if (misbehavior.kind === "applied") {
+		misbehavior = prepareInteractionsMisbehavior(misbehavior, streaming);
+		response = misbehavior.response;
+	}
+	const appliedUsage = misbehavior.kind === "applied" ? resolveOpenAIChatMisbehaviorUsage(misbehavior, completionReq) : void 0;
 	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({
+		recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		writeErrorResponse(res, status, JSON.stringify(buildInteractionsErrorResponse(response.error.message, response.error.type ?? "ERROR")), { retryAfter: response.retryAfter });
+		return;
+	}
+	if (misbehavior.kind === "applied" && misbehavior.summary.fault === "reasoning-only") {
+		const journalEntry = journal.add({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: flattenHeaders(req.headers),
 			body: completionReq,
 			response: {
-				status,
+				status: 200,
 				fixture
 			}
 		});
-		writeErrorResponse(res, status, JSON.stringify(buildInteractionsErrorResponse(response.error.message, response.error.type ?? "ERROR")), { retryAfter: response.retryAfter });
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const interactionId = nextInteractionId();
+		const usage = {
+			...interactionsUsage({ usage: appliedUsage }),
+			total_output_tokens: 0,
+			total_thought_tokens: appliedUsage?.completion_tokens ?? 0
+		};
+		if (!streaming) {
+			const overrides = isTextResponse(response) || isToolCallResponse(response) || isCombinedFixtureResponse(response) ? extractOverrides(response) : void 0;
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				id: interactionId,
+				model: overrides?.model ?? model,
+				status: "incomplete",
+				steps: [{
+					type: "thought",
+					signature: "",
+					summary: [{
+						type: "text",
+						text: misbehavior.reasoning ?? ""
+					}]
+				}],
+				usage
+			}));
+			return;
+		}
+		const events = [
+			{
+				event_type: "interaction.created",
+				interaction: {
+					id: interactionId,
+					status: "in_progress"
+				},
+				event_id: nextEventId()
+			},
+			{
+				event_type: "step.start",
+				index: 0,
+				step: { type: "thought" },
+				event_id: nextEventId()
+			},
+			{
+				event_type: "step.delta",
+				index: 0,
+				delta: {
+					type: "thought_summary",
+					content: {
+						type: "text",
+						text: misbehavior.reasoning ?? ""
+					}
+				},
+				event_id: nextEventId()
+			},
+			{
+				event_type: "step.stop",
+				index: 0,
+				event_id: nextEventId()
+			},
+			{
+				event_type: "interaction.completed",
+				interaction: {
+					id: interactionId,
+					status: "incomplete",
+					usage
+				},
+				event_id: nextEventId()
+			}
+		];
+		const interruption = createInterruptionSignal(fixture);
+		if (!await writeGeminiInteractionsSSEStream(res, events, {
+			latency,
+			streamingProfile: fixture.streamingProfile,
+			recordedTimings: fixture.recordedTimings,
+			replaySpeed,
+			signal: interruption?.signal,
+			onChunkSent: interruption?.tick
+		})) {
+			if (!res.writableEnded) res.destroy();
+			journalEntry.response.interrupted = true;
+			journalEntry.response.interruptReason = interruption?.reason();
+		}
+		interruption?.cleanup();
 		return;
 	}
-	const interactionId = nextInteractionId();
-	if (isContentWithToolCallsResponse(response)) {
+	if (isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini Interactions API — ignoring");
-		const overrides = extractOverrides(response);
+		const overrides = {
+			...extractOverrides(response),
+			...appliedUsage ? { usage: appliedUsage } : {}
+		};
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
 			path: urlPath,
@@ -650,14 +843,25 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = requireEmittedFunctionToolCalls(response, "Gemini Interactions");
+		const interactionId = nextInteractionId();
 		if (!streaming) {
-			const body = buildInteractionsContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], model, interactionId, logger, overrides, response.blocks);
+			const body = buildInteractionsContentWithToolCallsResponse(response.content ?? "", functionToolCalls, model, interactionId, logger, overrides, response.blocks);
 			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
+			res.end(JSON.stringify(misbehavior.kind === "applied" && misbehavior.summary.fault === "stop-length-mid-tool" ? {
+				...body,
+				status: "incomplete"
+			} : body));
 		} else {
-			const events = buildInteractionsContentWithToolCallsSSEEvents(response.content ?? "", response.toolCalls ?? [], interactionId, chunkSize, logger, overrides, response.blocks);
+			const events = buildInteractionsContentWithToolCallsSSEEvents(response.content ?? "", functionToolCalls, interactionId, chunkSize, logger, overrides, response.blocks);
 			const interruption = createInterruptionSignal(fixture);
-			if (!await writeGeminiInteractionsSSEStream(res, events, {
+			if (!await writeGeminiInteractionsSSEStream(res, finalizeInteractionsMisbehavior(events, misbehavior), {
 				latency,
 				streamingProfile: fixture.streamingProfile,
 				recordedTimings: fixture.recordedTimings,
@@ -675,7 +879,10 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 	}
 	if (isTextResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini Interactions API — ignoring");
-		const overrides = extractOverrides(response);
+		const overrides = {
+			...extractOverrides(response),
+			...appliedUsage ? { usage: appliedUsage } : {}
+		};
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
 			path: urlPath,
@@ -686,14 +893,24 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const interactionId = nextInteractionId();
 		if (!streaming) {
 			const body = buildInteractionsTextResponse(response.content, model, interactionId, overrides);
 			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
+			res.end(JSON.stringify(misbehavior.kind === "applied" && misbehavior.summary.fault === "stop-length-mid-tool" ? {
+				...body,
+				status: "incomplete"
+			} : body));
 		} else {
 			const events = buildInteractionsTextSSEEvents(response.content, interactionId, chunkSize, overrides);
 			const interruption = createInterruptionSignal(fixture);
-			if (!await writeGeminiInteractionsSSEStream(res, events, {
+			if (!await writeGeminiInteractionsSSEStream(res, finalizeInteractionsMisbehavior(events, misbehavior), {
 				latency,
 				streamingProfile: fixture.streamingProfile,
 				recordedTimings: fixture.recordedTimings,
@@ -711,7 +928,10 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 	}
 	if (isToolCallResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Gemini Interactions API — ignoring");
-		const overrides = extractOverrides(response);
+		const overrides = {
+			...extractOverrides(response),
+			...appliedUsage ? { usage: appliedUsage } : {}
+		};
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
 			path: urlPath,
@@ -722,14 +942,25 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 				fixture
 			}
 		});
+		recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = requireEmittedFunctionToolCalls(response, "Gemini Interactions");
+		const interactionId = nextInteractionId();
 		if (!streaming) {
-			const body = buildInteractionsToolCallResponse(response.toolCalls, model, interactionId, logger, overrides);
+			const body = buildInteractionsToolCallResponse(functionToolCalls, model, interactionId, logger, overrides);
 			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
+			res.end(JSON.stringify(misbehavior.kind === "applied" && misbehavior.summary.fault === "stop-length-mid-tool" ? {
+				...body,
+				status: "incomplete"
+			} : body));
 		} else {
-			const events = buildInteractionsToolCallSSEEvents(response.toolCalls, interactionId, logger, overrides);
+			const events = buildInteractionsToolCallSSEEvents(functionToolCalls, interactionId, logger, overrides);
 			const interruption = createInterruptionSignal(fixture);
-			if (!await writeGeminiInteractionsSSEStream(res, events, {
+			if (!await writeGeminiInteractionsSSEStream(res, finalizeInteractionsMisbehavior(events, misbehavior), {
 				latency,
 				streamingProfile: fixture.streamingProfile,
 				recordedTimings: fixture.recordedTimings,
@@ -745,15 +976,20 @@ async function handleGeminiInteractions(req, res, raw, fixtures, journal, defaul
 		}
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path: urlPath,
-		headers: flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path: urlPath,
+			headers: flattenHeaders(req.headers),
+			body: completionReq,
+			response: {
+				status: 500,
+				fixture
+			}
+		}),
+		summary: misbehavior.summary,
+		defaults,
+		testId
 	});
 	writeErrorResponse(res, 500, JSON.stringify(buildInteractionsErrorResponse("Fixture response did not match any known type", "INTERNAL")));
 }