@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/ollama.cjs

@@ -1,6 +1,7 @@
 const require_helpers = require('./helpers.cjs');
 const require_sse_writer = require('./sse-writer.cjs');
 const require_chaos = require('./chaos.cjs');
+const require_misbehavior = require('./misbehavior.cjs');
 const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
 const require_interruption = require('./interruption.cjs');
@@ -122,20 +123,8 @@ function buildOllamaChatTextResponse(content, model, reasoning) {
 		...DURATION_FIELDS
 	};
 }
-function buildOllamaChatToolCallChunks(toolCalls, model, chunkSize, logger, reasoning) {
-	const ollamaToolCalls = toolCalls.map((tc) => {
-		let argsObj;
-		try {
-			argsObj = JSON.parse(tc.arguments || "{}");
-		} catch {
-			logger.warn(`Malformed JSON in fixture tool call arguments for "${tc.name}": ${tc.arguments}`);
-			argsObj = {};
-		}
-		return { function: {
-			name: tc.name,
-			arguments: argsObj
-		} };
-	});
+function buildOllamaChatToolCallChunks(toolCalls, model, chunkSize, reasoning) {
+	const ollamaToolCalls = toolCalls.map(toOllamaToolCall);
 	const chunks = [];
 	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
 	if (reasoning) for (let i = 0; i < reasoning.length; i += chunkSize) {
@@ -173,20 +162,8 @@ function buildOllamaChatToolCallChunks(toolCalls, model, chunkSize, logger, reas
 	});
 	return chunks;
 }
-function buildOllamaChatToolCallResponse(toolCalls, model, logger, reasoning) {
-	const ollamaToolCalls = toolCalls.map((tc) => {
-		let argsObj;
-		try {
-			argsObj = JSON.parse(tc.arguments || "{}");
-		} catch {
-			logger.warn(`Malformed JSON in fixture tool call arguments for "${tc.name}": ${tc.arguments}`);
-			argsObj = {};
-		}
-		return { function: {
-			name: tc.name,
-			arguments: argsObj
-		} };
-	});
+function buildOllamaChatToolCallResponse(toolCalls, model, reasoning) {
+	const ollamaToolCalls = toolCalls.map(toOllamaToolCall);
 	return {
 		model,
 		created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -200,20 +177,13 @@ function buildOllamaChatToolCallResponse(toolCalls, model, logger, reasoning) {
 		...DURATION_FIELDS
 	};
 }
-function toOllamaToolCall(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 = {};
-	}
+function toOllamaToolCall(tc) {
 	return { function: {
 		name: tc.name,
-		arguments: argsObj
+		arguments: require_helpers.servedToolArgs(tc, "object").value
 	} };
 }
-function buildOllamaChatContentWithToolCallsChunks(content, toolCalls, model, chunkSize, logger, reasoning, blocks) {
+function buildOllamaChatContentWithToolCallsChunks(content, toolCalls, model, chunkSize, reasoning, blocks) {
 	const chunks = [];
 	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
 	if (blocks && blocks.length > 0) {
@@ -249,7 +219,7 @@ function buildOllamaChatContentWithToolCallsChunks(content, toolCalls, model, ch
 			message: {
 				role: "assistant",
 				content: "",
-				tool_calls: [toOllamaToolCall(block, logger)]
+				tool_calls: [toOllamaToolCall(block)]
 			},
 			done: false
 		});
@@ -290,19 +260,7 @@ function buildOllamaChatContentWithToolCallsChunks(content, toolCalls, model, ch
 			done: false
 		});
 	}
-	const ollamaToolCalls = toolCalls.map((tc) => {
-		let argsObj;
-		try {
-			argsObj = JSON.parse(tc.arguments || "{}");
-		} catch {
-			logger.warn(`Malformed JSON in fixture tool call arguments for "${tc.name}": ${tc.arguments}`);
-			argsObj = {};
-		}
-		return { function: {
-			name: tc.name,
-			arguments: argsObj
-		} };
-	});
+	const ollamaToolCalls = toolCalls.map(toOllamaToolCall);
 	chunks.push({
 		model,
 		created_at: createdAt,
@@ -325,7 +283,7 @@ function buildOllamaChatContentWithToolCallsChunks(content, toolCalls, model, ch
 	});
 	return chunks;
 }
-function buildOllamaChatContentWithToolCallsResponse(content, toolCalls, model, logger, reasoning, blocks) {
+function buildOllamaChatContentWithToolCallsResponse(content, toolCalls, model, reasoning, blocks) {
 	if (blocks && blocks.length > 0) {
 		const ordered = require_helpers.resolveFixtureBlocks(blocks);
 		content = ordered.filter((b) => b.type === "text").map((b) => b.text).join("");
@@ -334,19 +292,7 @@ function buildOllamaChatContentWithToolCallsResponse(content, toolCalls, model,
 			arguments: b.arguments
 		}));
 	}
-	const ollamaToolCalls = toolCalls.map((tc) => {
-		let argsObj;
-		try {
-			argsObj = JSON.parse(tc.arguments || "{}");
-		} catch {
-			logger.warn(`Malformed JSON in fixture tool call arguments for "${tc.name}": ${tc.arguments}`);
-			argsObj = {};
-		}
-		return { function: {
-			name: tc.name,
-			arguments: argsObj
-		} };
-	});
+	const ollamaToolCalls = toolCalls.map(toOllamaToolCall);
 	return {
 		model,
 		created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -360,6 +306,105 @@ function buildOllamaChatContentWithToolCallsResponse(content, toolCalls, model,
 		...DURATION_FIELDS
 	};
 }
+/** Prepare fault output and its observations together before sending any bytes. */
+function prepareOllamaMisbehavior(plan, request, stream, chunkSize, effectiveStrict, logger) {
+	const response = plan.response;
+	const combined = require_helpers.isCombinedFixtureResponse(response);
+	const outcome = combined && response.blocks?.length ? require_helpers.resolveFixtureBlockOutcome(response.blocks) : void 0;
+	const calls = outcome?.toolCalls ?? (combined || require_helpers.isToolCallResponse(response) ? response.toolCalls ?? [] : []);
+	const content = outcome?.content ?? ("content" in response ? response.content ?? "" : "");
+	const model = request.model;
+	if (plan.summary.fault === "tool-args-invalid-json") {
+		const target = calls[plan.target?.index ?? 0];
+		if (!target || require_helpers.toolArgsForWire(target).kind !== "verbatim") throw new Error("Ollama invalid-JSON fault requires an invalid prepared target");
+		const diagnostic = new require_helpers.InvalidToolArgumentsError(target).parseDiagnostic;
+		const error = `error parsing tool call: raw='${target.arguments}', err=${diagnostic}`;
+		let priorContent = content;
+		if (outcome) {
+			priorContent = "";
+			let index = 0;
+			for (const block of outcome.ordered) if (block.type === "text") priorContent += block.text;
+			else if (index++ === plan.target?.index) break;
+		}
+		return {
+			chunks: stream ? [...buildOllamaChatTextChunks(priorContent, model, chunkSize).slice(0, -1), { error }] : [{ error }],
+			status: stream ? 200 : 500,
+			summary: {
+				...plan.summary,
+				servedToolCalls: []
+			}
+		};
+	}
+	const servedToolCalls = calls.map((call) => {
+		const parsed = require_helpers.toolArgsForWire(call);
+		if (parsed.kind === "verbatim") throw new require_helpers.InvalidToolArgumentsError(call);
+		return {
+			name: call.name,
+			arguments: parsed.text
+		};
+	});
+	let chunks;
+	let reasoning = "";
+	if (plan.summary.fault === "reasoning-only") {
+		reasoning = plan.reasoning ?? "";
+		const base = {
+			model,
+			created_at: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (stream) {
+			chunks = [];
+			for (let i = 0; i < reasoning.length; i += chunkSize) chunks.push({
+				...base,
+				message: {
+					role: "assistant",
+					content: "",
+					thinking: reasoning.slice(i, i + chunkSize)
+				},
+				done: false
+			});
+			chunks.push({
+				...base,
+				message: {
+					role: "assistant",
+					content: ""
+				},
+				done: true,
+				...DURATION_FIELDS,
+				done_reason: "length"
+			});
+		} else chunks = [{
+			...base,
+			message: {
+				role: "assistant",
+				content: "",
+				thinking: reasoning
+			},
+			done: true,
+			...DURATION_FIELDS,
+			done_reason: "length"
+		}];
+	} else {
+		reasoning = require_helpers.resolveReasoningForModel("reasoning" in response ? response.reasoning : void 0, model, effectiveStrict, logger) ?? "";
+		if (combined) chunks = stream ? buildOllamaChatContentWithToolCallsChunks(content, calls, model, chunkSize, reasoning, response.blocks) : [buildOllamaChatContentWithToolCallsResponse(content, calls, model, reasoning, response.blocks)];
+		else if (require_helpers.isToolCallResponse(response)) chunks = stream ? buildOllamaChatToolCallChunks(calls, model, chunkSize, reasoning) : [buildOllamaChatToolCallResponse(calls, model, reasoning)];
+		else chunks = stream ? buildOllamaChatTextChunks(content, model, chunkSize, reasoning) : [buildOllamaChatTextResponse(content, model, reasoning)];
+	}
+	const completion = content + reasoning + servedToolCalls.map((call) => call.name + call.arguments).join("");
+	const terminal = chunks.length - 1;
+	chunks[terminal] = {
+		...chunks[terminal],
+		prompt_eval_count: require_helpers.estimatePromptTokens(request.messages),
+		eval_count: require_helpers.estimateTokens(completion)
+	};
+	return {
+		chunks,
+		status: 200,
+		summary: {
+			...plan.summary,
+			servedToolCalls
+		}
+	};
+}
 function buildOllamaGenerateTextChunks(content, model, chunkSize, reasoning) {
 	const chunks = [];
 	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -445,7 +490,11 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 		} }));
 		return;
 	}
-	const chatShapeError = require_helpers.validateChatMessages(ollamaReq.messages) ?? require_helpers.validateToolsField(ollamaReq.tools);
+	let chatShapeError = require_helpers.validateChatMessages(ollamaReq.messages) ?? require_helpers.validateToolsField(ollamaReq.tools);
+	if (!chatShapeError && Array.isArray(ollamaReq.tools)) {
+		const missingFunctionIndex = ollamaReq.tools.findIndex((tool) => tool.function === null || tool.function === void 0);
+		if (missingFunctionIndex !== -1) chatShapeError = `tools[${missingFunctionIndex}].function must be an object`;
+	}
 	if (chatShapeError) {
 		journal.add({
 			method: req.method ?? "POST",
@@ -536,25 +585,100 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 		return;
 	}
 	const response = await require_helpers.resolveResponse(fixture, completionReq);
+	const misbehavior = require_misbehavior.planMisbehavior({
+		wire: "ollama",
+		fixture,
+		response,
+		request: completionReq,
+		stream: ollamaReq.stream !== false,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const message = `${misbehavior.code}: ${misbehavior.message}`;
+		if (!misbehavior.summary?.evaluations.length) defaults.logger.error(message);
+		require_sse_writer.writeErrorResponse(res, misbehavior.status, JSON.stringify({ error: message }));
+		return;
+	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const streaming = ollamaReq.stream !== false;
-	if (require_helpers.isErrorResponse(response)) {
-		const status = response.status ?? 500;
-		journal.add({
+	if (misbehavior.kind === "applied") {
+		const prepared = prepareOllamaMisbehavior(misbehavior, completionReq, streaming, chunkSize, require_helpers.resolveStrictMode(defaults.strict, req.headers), logger);
+		const journalEntry = journal.add({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: completionReq,
 			response: {
-				status,
+				status: prepared.status,
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: prepared.summary,
+			defaults,
+			testId
+		});
+		if (!streaming) {
+			res.writeHead(prepared.status, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(prepared.chunks[0]));
+		} else {
+			const interruption = require_interruption.createInterruptionSignal(fixture);
+			if (!await require_ndjson_writer.writeNDJSONStream(res, prepared.chunks, {
+				latency,
+				streamingProfile: fixture.streamingProfile,
+				recordedTimings: fixture.recordedTimings,
+				replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
+				signal: interruption?.signal,
+				onChunkSent: interruption?.tick
+			})) {
+				if (!res.writableEnded) res.destroy();
+				journalEntry.response.interrupted = true;
+				journalEntry.response.interruptReason = interruption?.reason();
+			}
+			interruption?.cleanup();
+		}
+		return;
+	}
+	if (require_helpers.isErrorResponse(response)) {
+		const status = response.status ?? 500;
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		require_sse_writer.writeErrorResponse(res, status, require_helpers.serializeErrorResponse(response), { retryAfter: response.retryAfter });
 		return;
 	}
-	if (require_helpers.isContentWithToolCallsResponse(response)) {
+	if (require_helpers.isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Ollama API -- ignoring");
 		const journalEntry = journal.add({
 			method: req.method ?? "POST",
@@ -566,14 +690,21 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Ollama");
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, logger);
 		if (!streaming) {
-			const body = buildOllamaChatContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], completionReq.model, logger, effReasoning, response.blocks);
+			const body = buildOllamaChatContentWithToolCallsResponse(response.content ?? "", functionToolCalls, completionReq.model, effReasoning, response.blocks);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const chunks = buildOllamaChatContentWithToolCallsChunks(response.content ?? "", response.toolCalls ?? [], completionReq.model, chunkSize, logger, effReasoning, response.blocks);
+			const chunks = buildOllamaChatContentWithToolCallsChunks(response.content ?? "", functionToolCalls, completionReq.model, chunkSize, effReasoning, response.blocks);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await require_ndjson_writer.writeNDJSONStream(res, chunks, {
 				latency,
@@ -603,6 +734,12 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, logger);
 		if (!streaming) {
@@ -640,14 +777,21 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Ollama");
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, logger);
 		if (!streaming) {
-			const body = buildOllamaChatToolCallResponse(response.toolCalls, completionReq.model, logger, effReasoning);
+			const body = buildOllamaChatToolCallResponse(functionToolCalls, completionReq.model, effReasoning);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const chunks = buildOllamaChatToolCallChunks(response.toolCalls, completionReq.model, chunkSize, logger, effReasoning);
+			const chunks = buildOllamaChatToolCallChunks(functionToolCalls, completionReq.model, chunkSize, effReasoning);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await require_ndjson_writer.writeNDJSONStream(res, chunks, {
 				latency,
@@ -665,15 +809,20 @@ async function handleOllama(req, res, raw, fixtures, journal, defaults, setCorsH
 		}
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path: urlPath,
-		headers: require_helpers.flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	require_misbehavior.recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path: urlPath,
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: completionReq,
+			response: {
+				status: 500,
+				fixture
+			}
+		}),
+		summary: misbehavior.summary,
+		defaults,
+		testId
 	});
 	require_sse_writer.writeErrorResponse(res, 500, JSON.stringify({ error: {
 		message: "Fixture response did not match any known type",
@@ -811,20 +960,57 @@ async function handleOllamaGenerate(req, res, raw, fixtures, journal, defaults,
 		return;
 	}
 	const response = await require_helpers.resolveResponse(fixture, completionReq);
+	const misbehavior = require_misbehavior.planMisbehavior({
+		wire: "ollama",
+		faultRenderingAvailable: false,
+		fixture,
+		response,
+		request: completionReq,
+		stream: generateReq.stream !== false,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const message = `${misbehavior.code}: ${misbehavior.message}`;
+		if (!misbehavior.summary?.evaluations.length) defaults.logger.error(message);
+		require_sse_writer.writeErrorResponse(res, misbehavior.status, JSON.stringify({ error: message }));
+		return;
+	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
 	const streaming = generateReq.stream !== false;
 	if (require_helpers.isErrorResponse(response)) {
 		const status = response.status ?? 500;
-		journal.add({
-			method: req.method ?? "POST",
-			path: urlPath,
-			headers: require_helpers.flattenHeaders(req.headers),
-			body: completionReq,
-			response: {
-				status,
-				fixture
-			}
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
 		});
 		require_sse_writer.writeErrorResponse(res, status, require_helpers.serializeErrorResponse(response), { retryAfter: response.retryAfter });
 		return;
@@ -840,6 +1026,12 @@ async function handleOllamaGenerate(req, res, raw, fixtures, journal, defaults,
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, defaults.logger);
 		if (!streaming) {
@@ -865,16 +1057,21 @@ async function handleOllamaGenerate(req, res, raw, fixtures, journal, defaults,
 		}
 		return;
 	}
-	if (require_helpers.isToolCallResponse(response) || require_helpers.isContentWithToolCallsResponse(response)) {
-		journal.add({
-			method: req.method ?? "POST",
-			path: urlPath,
-			headers: require_helpers.flattenHeaders(req.headers),
-			body: completionReq,
-			response: {
-				status: 400,
-				fixture
-			}
+	if (require_helpers.isToolCallResponse(response) || require_helpers.isCombinedFixtureResponse(response)) {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: urlPath,
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: 400,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
 		});
 		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
 			message: "Tool call fixtures are not supported on /api/generate — use /api/chat instead",
@@ -882,15 +1079,20 @@ async function handleOllamaGenerate(req, res, raw, fixtures, journal, defaults,
 		} }));
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path: urlPath,
-		headers: require_helpers.flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	require_misbehavior.recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path: urlPath,
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: completionReq,
+			response: {
+				status: 500,
+				fixture
+			}
+		}),
+		summary: misbehavior.summary,
+		defaults,
+		testId
 	});
 	require_sse_writer.writeErrorResponse(res, 500, JSON.stringify({ error: {
 		message: "Fixture response did not match any known type",