@copilotkit/aimock 1.44.0 → 1.45.0

package/dist/messages.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');
@@ -385,14 +386,7 @@ function buildClaudeToolCallStreamEvents(toolCalls, model, chunkSize, logger, re
 	}
 	for (const tc of toolCalls) {
 		const toolUseId = tc.id || require_helpers.generateToolUseId();
-		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 argsJson = JSON.stringify(argsObj);
+		const argsJson = require_helpers.servedToolArgs(tc, "string", logger).text;
 		events.push({
 			type: "content_block_start",
 			index: blockIndex,
@@ -481,13 +475,7 @@ function buildClaudeToolCallResponse(toolCalls, model, logger, reasoning, overri
 		signature: reasoningSignature ?? PLACEHOLDER_SIGNATURE
 	});
 	for (const tc of toolCalls) {
-		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 argsObj = require_helpers.servedToolArgs(tc, "object", logger).value;
 		contentBlocks.push({
 			type: "tool_use",
 			id: tc.id || require_helpers.generateToolUseId(),
@@ -591,14 +579,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 			blockIndex++;
 		} else {
 			const toolUseId = block.id || require_helpers.generateToolUseId();
-			let argsObj;
-			try {
-				argsObj = JSON.parse(block.arguments || "{}");
-			} catch {
-				logger.warn(`Malformed JSON in fixture tool call arguments for "${block.name}": ${block.arguments}`);
-				argsObj = {};
-			}
-			const argsJson = JSON.stringify(argsObj);
+			const argsJson = require_helpers.servedToolArgs(block, "string", logger).text;
 			events.push({
 				type: "content_block_start",
 				index: blockIndex,
@@ -663,14 +644,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 	blockIndex++;
 	for (const tc of toolCalls) {
 		const toolUseId = tc.id || require_helpers.generateToolUseId();
-		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 argsJson = JSON.stringify(argsObj);
+		const argsJson = require_helpers.servedToolArgs(tc, "string", logger).text;
 		events.push({
 			type: "content_block_start",
 			index: blockIndex,
@@ -718,13 +692,7 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 		signature: reasoningSignature ?? PLACEHOLDER_SIGNATURE
 	});
 	const toolUseBlock = (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 = {};
-		}
+		const argsObj = require_helpers.servedToolArgs(tc, "object", logger).value;
 		return {
 			type: "tool_use",
 			id: tc.id || require_helpers.generateToolUseId(),
@@ -764,6 +732,227 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 		usage: claudeUsage(overrides)
 	};
 }
+/**
+* Prepare an already-selected Claude fault once for Messages or InvokeModel.
+* IDs, canonical served arguments and usage describe the full emitted output,
+* even when the transport later interrupts delivery. Never mutates the plan.
+*/
+function prepareClaudeMisbehavior(plan, context) {
+	const response = plan.response;
+	if (!(require_helpers.isTextResponse(response) || require_helpers.isToolCallResponse(response) || require_helpers.isCombinedFixtureResponse(response))) throw new TypeError("Claude misbehavior requires a chat response");
+	const outcome = require_helpers.isCombinedFixtureResponse(response) && response.blocks?.length ? require_helpers.resolveFixtureBlockOutcome(response.blocks) : void 0;
+	const toolCalls = (outcome?.toolCalls ?? ("toolCalls" in response ? response.toolCalls ?? [] : [])).map((call, index) => ({
+		...call,
+		...!context.stream && plan.summary.fault === "stop-length-mid-tool" && index === plan.summary.target?.index ? { arguments: "{}" } : {},
+		...index === plan.duplicateId?.destinationIndex ? {} : { id: call.id || require_helpers.generateToolUseId() }
+	}));
+	if (plan.duplicateId) toolCalls[plan.duplicateId.destinationIndex].id = toolCalls[plan.duplicateId.sourceIndex].id;
+	let preparedResponse = { ...response };
+	delete preparedResponse.usage;
+	if (outcome) {
+		let index = 0;
+		preparedResponse = {
+			...preparedResponse,
+			content: outcome.content,
+			toolCalls,
+			blocks: outcome.ordered.map((block) => block.type === "text" ? { ...block } : {
+				...block,
+				...toolCalls[index++]
+			})
+		};
+	} else if ("toolCalls" in response) preparedResponse = {
+		...preparedResponse,
+		toolCalls
+	};
+	const servedToolCalls = toolCalls.map((call) => {
+		const args = require_helpers.toolArgsForWire(call);
+		return {
+			name: call.name,
+			id: call.id,
+			arguments: args.kind === "parsed" ? args.text : args.raw
+		};
+	});
+	const preparedPlan = {
+		...plan,
+		response: preparedResponse,
+		summary: {
+			...plan.summary,
+			servedToolCalls
+		}
+	};
+	const reasoning = plan.summary.fault === "reasoning-only" ? plan.reasoning ?? "" : require_helpers.resolveReasoningForModel(response.reasoning, context.request.model, context.strict, context.logger);
+	const artifacts = require_helpers.resolveReasoningArtifactsForModel(response.reasoningSignature, response.redactedThinking, context.request.model, context.strict, context.logger);
+	const content = outcome?.content ?? ("content" in response ? response.content ?? "" : "");
+	const usage = {
+		input_tokens: require_helpers.estimatePromptTokens(context.request.messages),
+		output_tokens: require_helpers.estimateTokens(content + servedToolCalls.map((call) => call.name + call.arguments).join("") + (reasoning ?? "") + (plan.refusal ?? ""))
+	};
+	const overrides = {
+		...require_helpers.extractOverrides(response),
+		...plan.stop === "length" ? { finishReason: "length" } : {},
+		usage
+	};
+	const model = context.request.model;
+	if (plan.summary.fault === "reasoning-only") {
+		const thought = reasoning ?? "";
+		const signature = artifacts.reasoningSignature ?? PLACEHOLDER_SIGNATURE;
+		const body = {
+			id: overrides.id ?? require_helpers.generateMessageId(),
+			type: "message",
+			role: overrides.role ?? "assistant",
+			content: [{
+				type: "thinking",
+				thinking: thought,
+				signature
+			}],
+			model: overrides.model ?? model,
+			stop_reason: "max_tokens",
+			stop_sequence: null,
+			usage
+		};
+		if (!context.stream) return {
+			stream: false,
+			body,
+			plan: preparedPlan,
+			usage
+		};
+		const events = [{
+			type: "message_start",
+			message: {
+				...body,
+				content: [],
+				stop_reason: null
+			}
+		}, {
+			type: "content_block_start",
+			index: 0,
+			content_block: {
+				type: "thinking",
+				thinking: "",
+				signature: ""
+			}
+		}];
+		const size = Math.max(1, context.chunkSize);
+		for (let offset = 0; offset < thought.length; offset += size) events.push({
+			type: "content_block_delta",
+			index: 0,
+			delta: {
+				type: "thinking_delta",
+				thinking: thought.slice(offset, offset + size)
+			}
+		});
+		events.push({
+			type: "content_block_delta",
+			index: 0,
+			delta: {
+				type: "signature_delta",
+				signature
+			}
+		}, {
+			type: "content_block_stop",
+			index: 0
+		}, {
+			type: "message_delta",
+			delta: {
+				stop_reason: "max_tokens",
+				stop_sequence: null
+			},
+			usage: { output_tokens: usage.output_tokens }
+		}, { type: "message_stop" });
+		return {
+			stream: true,
+			events,
+			plan: preparedPlan,
+			usage
+		};
+	}
+	if (plan.summary.fault === "empty-response" || plan.summary.fault === "refusal") {
+		const stop = plan.stop === "refusal" ? "refusal" : "end_turn";
+		const detail = plan.stop === "refusal" ? { stop_details: {
+			type: "refusal",
+			category: plan.refusalCategory ?? null,
+			explanation: plan.refusal ?? ""
+		} } : {};
+		const body = {
+			id: overrides.id ?? require_helpers.generateMessageId(),
+			type: "message",
+			role: overrides.role ?? "assistant",
+			content: [],
+			model: overrides.model ?? model,
+			stop_reason: stop,
+			stop_sequence: null,
+			...detail,
+			usage
+		};
+		if (!context.stream) return {
+			stream: false,
+			body,
+			plan: preparedPlan,
+			usage
+		};
+		return {
+			stream: true,
+			events: [
+				{
+					type: "message_start",
+					message: {
+						...body,
+						stop_reason: null,
+						..."stop_details" in detail ? { stop_details: void 0 } : {}
+					}
+				},
+				{
+					type: "message_delta",
+					delta: {
+						stop_reason: stop,
+						stop_sequence: null,
+						...detail
+					},
+					usage: { output_tokens: usage.output_tokens }
+				},
+				{ type: "message_stop" }
+			],
+			plan: preparedPlan,
+			usage
+		};
+	}
+	if (context.stream) {
+		const args = [
+			reasoning,
+			overrides,
+			artifacts.reasoningSignature,
+			artifacts.redactedThinking
+		];
+		const events = require_helpers.isCombinedFixtureResponse(preparedResponse) ? buildClaudeContentWithToolCallsStreamEvents(preparedResponse.content ?? "", toolCalls, model, Math.max(1, context.chunkSize), context.logger, ...args, preparedResponse.blocks) : require_helpers.isToolCallResponse(preparedResponse) ? buildClaudeToolCallStreamEvents(toolCalls, model, Math.max(1, context.chunkSize), context.logger, ...args) : buildClaudeTextStreamEvents(content, model, Math.max(1, context.chunkSize), ...args);
+		if (plan.summary.fault === "stop-length-mid-tool") {
+			const cutIndex = events.filter((event) => event.type === "content_block_start" && require_helpers.isJsonObject(event.content_block) && event.content_block.type === "tool_use")[plan.target?.index ?? 0]?.index;
+			return {
+				stream: true,
+				events: events.filter((event) => !(event.type === "content_block_stop" && event.index === cutIndex)),
+				plan: preparedPlan,
+				usage
+			};
+		}
+		return {
+			stream: true,
+			events,
+			plan: preparedPlan,
+			usage
+		};
+	}
+	const args = [
+		reasoning,
+		overrides,
+		artifacts.reasoningSignature,
+		artifacts.redactedThinking
+	];
+	return {
+		stream: false,
+		body: require_helpers.isCombinedFixtureResponse(preparedResponse) ? buildClaudeContentWithToolCallsResponse(preparedResponse.content ?? "", toolCalls, model, context.logger, ...args, preparedResponse.blocks) : require_helpers.isToolCallResponse(preparedResponse) ? buildClaudeToolCallResponse(toolCalls, model, context.logger, ...args) : buildClaudeTextResponse(content, model, ...args),
+		plan: preparedPlan,
+		usage
+	};
+}
 async function writeClaudeSSEStream(res, events, optionsOrLatency) {
 	const opts = typeof optionsOrLatency === "number" ? { latency: optionsOrLatency } : optionsOrLatency ?? {};
 	const latency = opts.latency ?? 0;
@@ -972,20 +1161,111 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		return;
 	}
 	const response = await require_helpers.resolveResponse(fixture, completionReq);
+	const misbehavior = require_misbehavior.planMisbehavior({
+		wire: "anthropic",
+		fixture,
+		response,
+		request: completionReq,
+		stream: claudeReq.stream === true,
+		emitsToolCallIds: true,
+		defaults,
+		rawHeaders: req.headers,
+		url: req.url
+	});
+	if (misbehavior.kind === "error") {
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? "/v1/messages",
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status: misbehavior.status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		if (!misbehavior.summary?.evaluations.length) logger.error(`POST /v1/messages: ${misbehavior.message}`);
+		require_sse_writer.writeErrorResponse(res, misbehavior.status, JSON.stringify({
+			type: "error",
+			error: {
+				type: misbehavior.status === 400 ? "invalid_request_error" : "api_error",
+				code: misbehavior.code,
+				message: misbehavior.message
+			}
+		}));
+		return;
+	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
-	if (require_helpers.isErrorResponse(response)) {
-		const status = response.status ?? 500;
-		journal.add({
+	if (misbehavior.kind === "applied") {
+		const prepared = prepareClaudeMisbehavior(misbehavior, {
+			request: completionReq,
+			stream: claudeReq.stream === true,
+			chunkSize,
+			logger,
+			strict: require_helpers.resolveStrictMode(defaults.strict, req.headers)
+		});
+		const entry = journal.add({
 			method: req.method ?? "POST",
 			path: req.url ?? "/v1/messages",
 			headers: require_helpers.flattenHeaders(req.headers),
 			body: completionReq,
 			response: {
-				status,
+				status: 200,
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry,
+			summary: prepared.plan.summary,
+			defaults,
+			testId
+		});
+		if (!prepared.stream) {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(prepared.body));
+		} else {
+			const interruption = require_interruption.createInterruptionSignal(fixture);
+			try {
+				if (!await writeClaudeSSEStream(res, prepared.events, {
+					latency,
+					streamingProfile: fixture.streamingProfile,
+					recordedTimings: fixture.recordedTimings,
+					replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
+					signal: interruption?.signal,
+					onChunkSent: interruption?.tick
+				})) {
+					if (!res.writableEnded) res.destroy();
+					entry.response.interrupted = true;
+					entry.response.interruptReason = interruption?.reason();
+				}
+			} finally {
+				interruption?.cleanup();
+			}
+		}
+		return;
+	}
+	if (require_helpers.isErrorResponse(response)) {
+		const status = response.status ?? 500;
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? "/v1/messages",
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: completionReq,
+				response: {
+					status,
+					fixture
+				}
+			}),
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		const anthropicError = {
 			type: "error",
 			error: {
@@ -996,7 +1276,7 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		require_sse_writer.writeErrorResponse(res, status, JSON.stringify(anthropicError), { 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 Claude Messages API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
@@ -1012,12 +1292,19 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Anthropic Messages");
 		if (claudeReq.stream !== true) {
-			const body = buildClaudeContentWithToolCallsResponse(response.content ?? "", response.toolCalls ?? [], completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks);
+			const body = buildClaudeContentWithToolCallsResponse(response.content ?? "", functionToolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildClaudeContentWithToolCallsStreamEvents(response.content ?? "", response.toolCalls ?? [], completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks);
+			const events = buildClaudeContentWithToolCallsStreamEvents(response.content ?? "", functionToolCalls, completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeClaudeSSEStream(res, events, {
 				latency,
@@ -1051,6 +1338,12 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
 		if (claudeReq.stream !== true) {
 			const body = buildClaudeTextResponse(response.content, completionReq.model, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
 			res.writeHead(200, { "Content-Type": "application/json" });
@@ -1090,12 +1383,19 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture
 			}
 		});
+		require_misbehavior.recordMisbehaviorOutcome({
+			entry: journalEntry,
+			summary: misbehavior.summary,
+			defaults,
+			testId
+		});
+		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Anthropic Messages");
 		if (claudeReq.stream !== true) {
-			const body = buildClaudeToolCallResponse(response.toolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
+			const body = buildClaudeToolCallResponse(functionToolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
 			res.writeHead(200, { "Content-Type": "application/json" });
 			res.end(JSON.stringify(body));
 		} else {
-			const events = buildClaudeToolCallStreamEvents(response.toolCalls, completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
+			const events = buildClaudeToolCallStreamEvents(functionToolCalls, completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
 			const interruption = require_interruption.createInterruptionSignal(fixture);
 			if (!await writeClaudeSSEStream(res, events, {
 				latency,
@@ -1113,15 +1413,20 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		}
 		return;
 	}
-	journal.add({
-		method: req.method ?? "POST",
-		path: req.url ?? "/v1/messages",
-		headers: require_helpers.flattenHeaders(req.headers),
-		body: completionReq,
-		response: {
-			status: 500,
-			fixture
-		}
+	require_misbehavior.recordMisbehaviorOutcome({
+		entry: journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? "/v1/messages",
+			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",
@@ -1131,4 +1436,5 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 
 //#endregion
 exports.handleMessages = handleMessages;
+exports.prepareClaudeMisbehavior = prepareClaudeMisbehavior;
 //# sourceMappingURL=messages.cjs.map