@copilotkit/aimock 1.45.1 → 1.47.0

package/dist/messages.js

@@ -1,10 +1,18 @@
-import { estimatePromptTokens, estimateTokens, extractOverrides, flattenHeaders, generateMessageId, generateToolUseId, getContext, getTestId, isCombinedFixtureResponse, isErrorResponse, isJsonObject, isTextResponse, isToolCallResponse, requireEmittedFunctionToolCalls, resolveFixtureBlockOutcome, resolveReasoningArtifactsForModel, resolveReasoningForModel, resolveResponse, resolveStrictMode, servedToolArgs, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField, toolArgsForWire } from "./helpers.js";
-import { calculateDelay, delay, writeErrorResponse } from "./sse-writer.js";
+import { missingRequiredHeader } from "./response/profiles.js";
+import { renderError } from "./response/errors.js";
+import { resolvePolicy, resolveRequestDecisions, strictOverrideField } from "./response/policy.js";
+import { estimatePromptTokens, estimateTokens, extractOverrides, flattenHeaders, generateMessageId, generateToolUseId, getContext, getTestId, isCombinedFixtureResponse, isErrorResponse, isJsonObject, isRawResponse, isTextResponse, isToolCallResponse, rejectGeneratedFiles, requireEmittedFunctionToolCalls, resolveCitations, resolveFixtureBlockOutcome, resolveReasoningArtifactsForModel, resolveReasoningForModel, resolveRequestId, resolveResponse, servedToolArgs, strictNoMatchLogLine, strictNoMatchMessage, toolArgsForWire } from "./helpers.js";
+import { typedSseCodec, writeErrorResponse } from "./sse-writer.js";
 import { applyChaosAsync } from "./chaos.js";
 import { planMisbehavior, recordMisbehaviorOutcome } from "./misbehavior.js";
 import { matchFixtureDiagnostic, recordMatchOptions } from "./router.js";
+import { render, resolve } from "./response/usage/codecs/anthropic.js";
 import { proxyAndRecord } from "./recorder.js";
-import { createInterruptionSignal } from "./interruption.js";
+import { misbehaviorPayloadLength, servedPayloadLength } from "./response/timing.js";
+import { deliverJson, deliverStream } from "./response/deliver.js";
+import { proxyInterruption, withHangUpDetection } from "./response/proxy.js";
+import { serveRawResponse } from "./response/raw.js";
+import { mapAnthropicFinish } from "./response/finish.js";
 
 //#region src/messages.ts
 /**
@@ -191,20 +199,7 @@ function thinkingViolationMessage(v) {
 }
 function claudeStopReason(finishReason, defaultReason) {
 	if (!finishReason) return defaultReason;
-	if (finishReason === "stop") return "end_turn";
-	if (finishReason === "tool_calls") return "tool_use";
-	if (finishReason === "length") return "max_tokens";
-	return finishReason;
-}
-function claudeUsage(overrides) {
-	if (!overrides?.usage) return {
-		input_tokens: 0,
-		output_tokens: 0
-	};
-	return {
-		input_tokens: overrides.usage.input_tokens ?? overrides.usage.prompt_tokens ?? 0,
-		output_tokens: overrides.usage.output_tokens ?? overrides.usage.completion_tokens ?? 0
-	};
+	return mapAnthropicFinish(finishReason);
 }
 /**
 * Emit faithful Anthropic `redacted_thinking` content-block events at the head
@@ -240,6 +235,76 @@ function pushRedactedThinkingStreamEvents(events, startIndex, redactedThinking)
 	}
 	return blockIndex;
 }
+/**
+* Fixture `citations` as Anthropic `web_search_result_location` citations, the
+* URL-sourced citation type (see `CitationsWebSearchResultLocation` in
+* `@anthropic-ai/sdk`), grouped per text block. `texts` are the turn's text
+* blocks in order; citation offsets index their joined text, the same
+* convention as Chat Completions and Gemini. Each citation goes only to the
+* last text block whose start offset in the joined text is at or before the
+* citation's `startIndex`, with `cited_text` sliced from that block's own text
+* (cut off at the block's end).
+* `web_search_result_location` carries no offsets, so nothing is rebased.
+* `encrypted_index` is opaque on the real wire, so aimock fills a stable
+* base64 placeholder. File citations are skipped (see {@link resolveCitations}):
+* Anthropic has no citation type for an OpenAI file ID.
+*/
+function claudeBlockCitations(texts, overrides) {
+	const starts = [];
+	let offset = 0;
+	for (const text of texts) {
+		starts.push(offset);
+		offset += text.length;
+	}
+	const perBlock = texts.map(() => []);
+	if (texts.length === 0) {
+		resolveCitations("", overrides?.citations);
+		return perBlock;
+	}
+	resolveCitations(texts.join(""), overrides?.citations).forEach((c, i) => {
+		let owner = 0;
+		for (let k = 1; k < starts.length; k++) if (starts[k] <= c.startIndex) owner = k;
+		const start = starts[owner];
+		perBlock[owner].push({
+			type: "web_search_result_location",
+			cited_text: texts[owner].slice(c.startIndex - start, c.endIndex - start),
+			url: c.url,
+			title: c.title,
+			encrypted_index: Buffer.from(`aimock-citation:${i}:${c.url}`).toString("base64")
+		});
+	});
+	return perBlock;
+}
+/** {@link claudeBlockCitations} for a turn with a single text block. */
+function claudeCitations(text, overrides) {
+	return claudeBlockCitations([text], overrides)[0];
+}
+/** A text content block; `citations` is added only when it has some. */
+function claudeTextBlock(text, citations) {
+	return citations.length > 0 ? {
+		type: "text",
+		text,
+		citations
+	} : {
+		type: "text",
+		text
+	};
+}
+/**
+* Streamed form of a text block's citations: one `citations_delta` per
+* citation, after the block's text deltas and before its `content_block_stop`,
+* as in the Anthropic citations streaming example. Nothing when it has none.
+*/
+function claudeCitationDeltas(citations, index) {
+	return citations.map((citation) => ({
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "citations_delta",
+			citation
+		}
+	}));
+}
 function buildClaudeTextStreamEvents(content, model, chunkSize, reasoning, overrides, reasoningSignature, redactedThinking) {
 	const msgId = overrides?.id ?? generateMessageId();
 	const effectiveModel = overrides?.model ?? model;
@@ -255,7 +320,7 @@ function buildClaudeTextStreamEvents(content, model, chunkSize, reasoning, overr
 			model: effectiveModel,
 			stop_reason: null,
 			stop_sequence: null,
-			usage: claudeUsage(overrides)
+			usage: render(resolve(overrides), "messages-start")
 		}
 	});
 	let blockIndex = 0;
@@ -314,6 +379,7 @@ function buildClaudeTextStreamEvents(content, model, chunkSize, reasoning, overr
 			}
 		});
 	}
+	events.push(...claudeCitationDeltas(claudeCitations(content, overrides), blockIndex));
 	events.push({
 		type: "content_block_stop",
 		index: blockIndex
@@ -324,12 +390,13 @@ function buildClaudeTextStreamEvents(content, model, chunkSize, reasoning, overr
 			stop_reason: claudeStopReason(overrides?.finishReason, "end_turn"),
 			stop_sequence: null
 		},
-		usage: { output_tokens: claudeUsage(overrides).output_tokens }
+		usage: render(resolve(overrides), "messages-delta")
 	});
 	events.push({ type: "message_stop" });
 	return events;
 }
 function buildClaudeToolCallStreamEvents(toolCalls, model, chunkSize, logger, reasoning, overrides, reasoningSignature, redactedThinking) {
+	resolveCitations("", overrides?.citations);
 	const msgId = overrides?.id ?? generateMessageId();
 	const effectiveModel = overrides?.model ?? model;
 	const signature = reasoningSignature ?? PLACEHOLDER_SIGNATURE;
@@ -344,7 +411,7 @@ function buildClaudeToolCallStreamEvents(toolCalls, model, chunkSize, logger, re
 			model: effectiveModel,
 			stop_reason: null,
 			stop_sequence: null,
-			usage: claudeUsage(overrides)
+			usage: render(resolve(overrides), "messages-start")
 		}
 	});
 	let blockIndex = 0;
@@ -420,7 +487,7 @@ function buildClaudeToolCallStreamEvents(toolCalls, model, chunkSize, logger, re
 			stop_reason: claudeStopReason(overrides?.finishReason, "tool_use"),
 			stop_sequence: null
 		},
-		usage: { output_tokens: claudeUsage(overrides).output_tokens }
+		usage: render(resolve(overrides), "messages-delta")
 	});
 	events.push({ type: "message_stop" });
 	return events;
@@ -451,10 +518,7 @@ function buildClaudeTextResponse(content, model, reasoning, overrides, reasoning
 		thinking: reasoning,
 		signature: reasoningSignature ?? PLACEHOLDER_SIGNATURE
 	});
-	contentBlocks.push({
-		type: "text",
-		text: content
-	});
+	contentBlocks.push(claudeTextBlock(content, claudeCitations(content, overrides)));
 	return {
 		id: overrides?.id ?? generateMessageId(),
 		type: "message",
@@ -463,10 +527,11 @@ function buildClaudeTextResponse(content, model, reasoning, overrides, reasoning
 		model: overrides?.model ?? model,
 		stop_reason: claudeStopReason(overrides?.finishReason, "end_turn"),
 		stop_sequence: null,
-		usage: claudeUsage(overrides)
+		usage: render(resolve(overrides), "messages-final")
 	};
 }
 function buildClaudeToolCallResponse(toolCalls, model, logger, reasoning, overrides, reasoningSignature, redactedThinking) {
+	resolveCitations("", overrides?.citations);
 	const contentBlocks = [];
 	pushRedactedThinkingBlocks(contentBlocks, redactedThinking);
 	if (reasoning) contentBlocks.push({
@@ -491,7 +556,7 @@ function buildClaudeToolCallResponse(toolCalls, model, logger, reasoning, overri
 		model: overrides?.model ?? model,
 		stop_reason: claudeStopReason(overrides?.finishReason, "tool_use"),
 		stop_sequence: null,
-		usage: claudeUsage(overrides)
+		usage: render(resolve(overrides), "messages-final")
 	};
 }
 function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model, chunkSize, logger, reasoning, overrides, reasoningSignature, redactedThinking, blocks) {
@@ -509,7 +574,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 			model: effectiveModel,
 			stop_reason: null,
 			stop_sequence: null,
-			usage: claudeUsage(overrides)
+			usage: render(resolve(overrides), "messages-start")
 		}
 	});
 	let blockIndex = 0;
@@ -552,6 +617,8 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 	if (blocks && blocks.length > 0) {
 		const outcome = resolveFixtureBlockOutcome(blocks);
 		const ordered = outcome.ordered;
+		const textCitations = claudeBlockCitations(ordered.flatMap((b) => b.type === "text" ? [b.text] : []), overrides);
+		let textPos = 0;
 		for (const block of ordered) if (block.type === "text") {
 			events.push({
 				type: "content_block_start",
@@ -572,6 +639,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 					}
 				});
 			}
+			events.push(...claudeCitationDeltas(textCitations[textPos++] ?? [], blockIndex));
 			events.push({
 				type: "content_block_stop",
 				index: blockIndex
@@ -613,7 +681,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 				stop_reason: claudeStopReason(overrides?.finishReason, outcome.hasToolCalls ? "tool_use" : "end_turn"),
 				stop_sequence: null
 			},
-			usage: { output_tokens: claudeUsage(overrides).output_tokens }
+			usage: render(resolve(overrides), "messages-delta")
 		});
 		events.push({ type: "message_stop" });
 		return events;
@@ -637,6 +705,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 			}
 		});
 	}
+	events.push(...claudeCitationDeltas(claudeCitations(content, overrides), blockIndex));
 	events.push({
 		type: "content_block_stop",
 		index: blockIndex
@@ -678,7 +747,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 			stop_reason: claudeStopReason(overrides?.finishReason, "tool_use"),
 			stop_sequence: null
 		},
-		usage: { output_tokens: claudeUsage(overrides).output_tokens }
+		usage: render(resolve(overrides), "messages-delta")
 	});
 	events.push({ type: "message_stop" });
 	return events;
@@ -704,21 +773,17 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 	if (blocks && blocks.length > 0) {
 		const outcome = resolveFixtureBlockOutcome(blocks);
 		const ordered = outcome.ordered;
+		const textCitations = claudeBlockCitations(ordered.flatMap((b) => b.type === "text" ? [b.text] : []), overrides);
+		let textPos = 0;
 		blockHasTools = outcome.hasToolCalls;
-		for (const block of ordered) if (block.type === "text") contentBlocks.push({
-			type: "text",
-			text: block.text
-		});
+		for (const block of ordered) if (block.type === "text") contentBlocks.push(claudeTextBlock(block.text, textCitations[textPos++] ?? []));
 		else contentBlocks.push(toolUseBlock({
 			name: block.name,
 			arguments: block.arguments,
 			id: block.id
 		}));
 	} else {
-		contentBlocks.push({
-			type: "text",
-			text: content
-		});
+		contentBlocks.push(claudeTextBlock(content, claudeCitations(content, overrides)));
 		for (const tc of toolCalls) contentBlocks.push(toolUseBlock(tc));
 	}
 	return {
@@ -729,7 +794,7 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 		model: overrides?.model ?? model,
 		stop_reason: claudeStopReason(overrides?.finishReason, blockHasTools === false ? "end_turn" : "tool_use"),
 		stop_sequence: null,
-		usage: claudeUsage(overrides)
+		usage: render(resolve(overrides), "messages-final")
 	};
 }
 /**
@@ -783,12 +848,15 @@ function prepareClaudeMisbehavior(plan, context) {
 	const reasoning = plan.summary.fault === "reasoning-only" ? plan.reasoning ?? "" : resolveReasoningForModel(response.reasoning, context.request.model, context.strict, context.logger);
 	const artifacts = 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: estimatePromptTokens(context.request.messages),
-		output_tokens: estimateTokens(content + servedToolCalls.map((call) => call.name + call.arguments).join("") + (reasoning ?? "") + (plan.refusal ?? ""))
-	};
+	const resolvedUsage = resolve(void 0, {
+		inputTokens: estimatePromptTokens(context.request.messages),
+		outputTokens: estimateTokens(content + servedToolCalls.map((call) => call.name + call.arguments).join("") + (reasoning ?? "") + (plan.refusal ?? ""))
+	});
+	const usage = render(resolvedUsage, "messages-final", "applied-misbehavior");
+	const { citations, ...rest } = extractOverrides(response);
 	const overrides = {
-		...extractOverrides(response),
+		...rest,
+		...context.citations ? { citations } : {},
 		...plan.stop === "length" ? { finishReason: "length" } : {},
 		usage
 	};
@@ -811,6 +879,7 @@ function prepareClaudeMisbehavior(plan, context) {
 			usage
 		};
 		if (!context.stream) return {
+			reasoning,
 			stream: false,
 			body,
 			plan: preparedPlan,
@@ -857,9 +926,10 @@ function prepareClaudeMisbehavior(plan, context) {
 				stop_reason: "max_tokens",
 				stop_sequence: null
 			},
-			usage: { output_tokens: usage.output_tokens }
+			usage: render(resolvedUsage, "messages-delta", "applied-misbehavior")
 		}, { type: "message_stop" });
 		return {
+			reasoning,
 			stream: true,
 			events,
 			plan: preparedPlan,
@@ -885,12 +955,14 @@ function prepareClaudeMisbehavior(plan, context) {
 			usage
 		};
 		if (!context.stream) return {
+			reasoning,
 			stream: false,
 			body,
 			plan: preparedPlan,
 			usage
 		};
 		return {
+			reasoning,
 			stream: true,
 			events: [
 				{
@@ -908,7 +980,7 @@ function prepareClaudeMisbehavior(plan, context) {
 						stop_sequence: null,
 						...detail
 					},
-					usage: { output_tokens: usage.output_tokens }
+					usage: render(resolvedUsage, "messages-delta", "applied-misbehavior")
 				},
 				{ type: "message_stop" }
 			],
@@ -927,6 +999,7 @@ function prepareClaudeMisbehavior(plan, context) {
 		if (plan.summary.fault === "stop-length-mid-tool") {
 			const cutIndex = events.filter((event) => event.type === "content_block_start" && isJsonObject(event.content_block) && event.content_block.type === "tool_use")[plan.target?.index ?? 0]?.index;
 			return {
+				reasoning,
 				stream: true,
 				events: events.filter((event) => !(event.type === "content_block_stop" && event.index === cutIndex)),
 				plan: preparedPlan,
@@ -934,6 +1007,7 @@ function prepareClaudeMisbehavior(plan, context) {
 			};
 		}
 		return {
+			reasoning,
 			stream: true,
 			events,
 			plan: preparedPlan,
@@ -947,40 +1021,39 @@ function prepareClaudeMisbehavior(plan, context) {
 		artifacts.redactedThinking
 	];
 	return {
+		reasoning,
 		stream: false,
 		body: isCombinedFixtureResponse(preparedResponse) ? buildClaudeContentWithToolCallsResponse(preparedResponse.content ?? "", toolCalls, model, context.logger, ...args, preparedResponse.blocks) : 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;
-	const profile = opts.streamingProfile;
-	const { recordedTimings, replaySpeed } = opts;
-	const signal = opts.signal;
-	const onChunkSent = opts.onChunkSent;
-	if (res.writableEnded) return true;
-	res.setHeader("Content-Type", "text/event-stream");
-	res.setHeader("Cache-Control", "no-cache");
-	res.setHeader("Connection", "keep-alive");
-	let chunkIndex = 0;
-	for (const event of events) {
-		const chunkDelay = calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);
-		if (chunkDelay > 0) await delay(chunkDelay, signal);
-		if (signal?.aborted) return false;
-		if (res.writableEnded) return true;
-		res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
-		onChunkSent?.();
-		if (signal?.aborted) return false;
-		chunkIndex++;
-	}
-	if (!res.writableEnded) res.end();
-	return true;
-}
 async function handleMessages(req, res, raw, fixtures, journal, defaults, setCorsHeaders) {
 	const { logger } = defaults;
 	setCorsHeaders(res);
+	const missingHeader = resolvePolicy(defaults, req.headers).requiredHeaders === "enforce" ? missingRequiredHeader("messages", req.headers) : void 0;
+	if (missingHeader) {
+		const { id: requestId } = resolveRequestId(req.headers);
+		req.headers["x-request-id"] = requestId;
+		res.setHeader("X-Request-Id", requestId);
+		journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? "/v1/messages",
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 400,
+				fixture: null,
+				source: "internal",
+				...strictOverrideField(defaults.strict, req.headers)
+			}
+		});
+		writeErrorResponse(res, 400, renderError("messages", "thinking", {
+			message: `${missingHeader}: header is required`,
+			requestId
+		}).body);
+		return;
+	}
 	let claudeReq;
 	try {
 		claudeReq = JSON.parse(raw);
@@ -996,10 +1069,10 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture: null
 			}
 		});
-		writeErrorResponse(res, 400, JSON.stringify({ error: {
+		writeErrorResponse(res, 400, renderError("messages", "validation", {
 			message: `Malformed JSON: ${detail}`,
 			type: "invalid_request_error"
-		} }));
+		}).body);
 		return;
 	}
 	if (!isJsonObject(claudeReq)) {
@@ -1013,10 +1086,10 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture: null
 			}
 		});
-		writeErrorResponse(res, 400, JSON.stringify({ error: {
+		writeErrorResponse(res, 400, renderError("messages", "validation", {
 			message: "Request body must be a JSON object",
 			type: "invalid_request_error"
-		} }));
+		}).body);
 		return;
 	}
 	const messagesError = !Array.isArray(claudeReq.messages) ? "messages must be an array" : claudeReq.messages.some((message) => !isJsonObject(message)) ? "messages entries must be JSON objects" : claudeReq.messages.some((message) => (message.role === "user" || message.role === "assistant") && typeof message.content === "number") ? "messages content must be a string or an array of content blocks" : null;
@@ -1031,15 +1104,15 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture: null
 			}
 		});
-		writeErrorResponse(res, 400, JSON.stringify({ error: {
+		writeErrorResponse(res, 400, renderError("messages", "validation", {
 			message: messagesError,
 			type: "invalid_request_error"
-		} }));
+		}).body);
 		return;
 	}
 	const thinkingViolation = validateThinkingInvariants(claudeReq);
 	if (thinkingViolation) {
-		const effectiveStrict = resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = resolveRequestDecisions(defaults.strict, req.headers).thinkingRejection;
 		const violationMessage = thinkingViolationMessage(thinkingViolation);
 		if (effectiveStrict) {
 			logger.error(`THINKING: ${violationMessage}`);
@@ -1054,13 +1127,7 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 					...strictOverrideField(defaults.strict, req.headers)
 				}
 			});
-			writeErrorResponse(res, 400, JSON.stringify({
-				type: "error",
-				error: {
-					type: "invalid_request_error",
-					message: violationMessage
-				}
-			}));
+			writeErrorResponse(res, 400, renderError("messages", "thinking", { message: violationMessage }).body);
 			return;
 		}
 		logger.warn(`THINKING: ${violationMessage} (strict off — replaying anyway)`);
@@ -1078,17 +1145,20 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 					fixture: null
 				}
 			});
-			writeErrorResponse(res, 400, JSON.stringify({ error: {
+			writeErrorResponse(res, 400, renderError("messages", "validation", {
 				message: toolsError,
 				type: "invalid_request_error"
-			} }));
+			}).body);
 			return;
 		}
 	}
 	const completionReq = claudeToCompletionRequest(claudeReq);
 	completionReq._context = getContext(req);
 	const testId = getTestId(req);
-	const { fixture, skippedBySequenceOrTurn } = matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, recordMatchOptions(!!defaults.record, defaults.logger));
+	const { fixture, skippedBySequenceOrTurn } = matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, {
+		...recordMatchOptions(!!defaults.record, defaults.logger),
+		wire: "anthropic"
+	});
 	if (fixture) {
 		journal.incrementFixtureMatchCount(fixture, fixtures, testId);
 		logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
@@ -1104,7 +1174,7 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		body: completionReq
 	}, fixture ? "fixture" : "proxy", defaults.registry, defaults.logger)) return;
 	if (!fixture) {
-		if (resolveStrictMode(defaults.strict, req.headers)) {
+		if (resolveRequestDecisions(defaults.strict, req.headers).fixtureMiss) {
 			const strictStatus = 503;
 			const strictMessage = strictNoMatchMessage(skippedBySequenceOrTurn);
 			logger.error(strictNoMatchLogLine(req.method ?? "POST", req.url ?? "/v1/messages", skippedBySequenceOrTurn));
@@ -1119,14 +1189,14 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 					...strictOverrideField(defaults.strict, req.headers)
 				}
 			});
-			writeErrorResponse(res, strictStatus, JSON.stringify({ error: {
+			writeErrorResponse(res, strictStatus, renderError("messages", "strict-miss", {
 				message: strictMessage,
 				type: "invalid_request_error"
-			} }));
+			}).body);
 			return;
 		}
 		if (defaults.record) {
-			const outcome = await proxyAndRecord(req, res, completionReq, "anthropic", req.url ?? "/v1/messages", fixtures, defaults, raw);
+			const { outcome, clientHungUp } = await withHangUpDetection(req, res, () => proxyAndRecord(req, res, completionReq, "anthropic", req.url ?? "/v1/messages", fixtures, defaults, raw));
 			if (outcome === "handled_by_hook") return;
 			if (outcome !== "not_configured") {
 				journal.add({
@@ -1137,7 +1207,8 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 					response: {
 						status: res.statusCode ?? 200,
 						fixture: null,
-						source: "proxy"
+						source: "proxy",
+						...proxyInterruption(res, clientHungUp)
 					}
 				});
 				return;
@@ -1154,10 +1225,10 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				...strictOverrideField(defaults.strict, req.headers)
 			}
 		});
-		writeErrorResponse(res, 404, JSON.stringify({ error: {
+		writeErrorResponse(res, 404, renderError("messages", "fixture-miss", {
 			message: "No fixture matched",
 			type: "invalid_request_error"
-		} }));
+		}).body);
 		return;
 	}
 	const response = await resolveResponse(fixture, completionReq);
@@ -1189,26 +1260,31 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			testId
 		});
 		if (!misbehavior.summary?.evaluations.length) logger.error(`POST /v1/messages: ${misbehavior.message}`);
-		writeErrorResponse(res, misbehavior.status, JSON.stringify({
-			type: "error",
-			error: {
-				type: misbehavior.status === 400 ? "invalid_request_error" : "api_error",
-				code: misbehavior.code,
-				message: misbehavior.message
-			}
-		}));
+		writeErrorResponse(res, misbehavior.status, renderError("messages", "misbehavior", {
+			type: misbehavior.status === 400 ? "invalid_request_error" : "api_error",
+			code: misbehavior.code,
+			message: misbehavior.message
+		}).body);
 		return;
 	}
 	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
+	const replaySpeed = fixture.replaySpeed ?? defaults.replaySpeed;
+	const streamTiming = {
+		latency,
+		streamingProfile: fixture.streamingProfile,
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed
+	};
+	const jsonOpts = (payloadLength, duplicateId = false) => ({
+		surface: "other",
+		payloadLength,
+		chunkSize,
+		recordedTimings: fixture.recordedTimings,
+		duplicateId,
+		replaySpeed
+	});
 	if (misbehavior.kind === "applied") {
-		const prepared = prepareClaudeMisbehavior(misbehavior, {
-			request: completionReq,
-			stream: claudeReq.stream === true,
-			chunkSize,
-			logger,
-			strict: resolveStrictMode(defaults.strict, req.headers)
-		});
 		const entry = journal.add({
 			method: req.method ?? "POST",
 			path: req.url ?? "/v1/messages",
@@ -1219,6 +1295,15 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 				fixture
 			}
 		});
+		rejectGeneratedFiles(misbehavior.response, "Anthropic Messages");
+		const prepared = prepareClaudeMisbehavior(misbehavior, {
+			request: completionReq,
+			stream: claudeReq.stream === true,
+			chunkSize,
+			logger,
+			strict: resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression,
+			citations: true
+		});
 		recordMisbehaviorOutcome({
 			entry,
 			summary: prepared.plan.summary,
@@ -1226,27 +1311,26 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			testId
 		});
 		if (!prepared.stream) {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(prepared.body));
-		} else {
-			const 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();
-			}
-		}
+			const preparedBody = prepared.body;
+			await deliverJson(res, entry, fixture, () => preparedBody, jsonOpts(misbehaviorPayloadLength(misbehavior, misbehavior.reasoning === void 0 ? prepared.reasoning : void 0), !!misbehavior.duplicateId));
+		} else await deliverStream(res, entry, fixture, typedSseCodec(), prepared.events, streamTiming);
+		return;
+	}
+	if (isRawResponse(response)) {
+		await serveRawResponse({
+			wire: "anthropic",
+			stream: claudeReq.stream === true,
+			req,
+			res,
+			fixture,
+			response,
+			body: completionReq,
+			journal,
+			defaults,
+			testId,
+			misbehaviorSummary: misbehavior.summary,
+			errorWire: "messages"
+		});
 		return;
 	}
 	if (isErrorResponse(response)) {
@@ -1266,20 +1350,13 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			defaults,
 			testId
 		});
-		const anthropicError = {
-			type: "error",
-			error: {
-				type: response.error.type ?? "api_error",
-				message: response.error.message
-			}
-		};
-		writeErrorResponse(res, status, JSON.stringify(anthropicError), { retryAfter: response.retryAfter });
+		writeErrorResponse(res, status, renderError("messages", "fixture", response.error).body, { retryAfter: response.retryAfter });
 		return;
 	}
 	if (isCombinedFixtureResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Claude Messages API — ignoring");
 		const overrides = extractOverrides(response);
-		const effectiveStrict = resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, defaults.logger);
 		const { reasoningSignature: effReasoningSignature, redactedThinking: effRedactedThinking } = resolveReasoningArtifactsForModel(response.reasoningSignature, response.redactedThinking, completionReq.model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
@@ -1298,34 +1375,19 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			defaults,
 			testId
 		});
+		rejectGeneratedFiles(response, "Anthropic Messages");
 		const functionToolCalls = requireEmittedFunctionToolCalls(response, "Anthropic Messages");
-		if (claudeReq.stream !== true) {
-			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 {
+		if (claudeReq.stream !== true) await deliverJson(res, journalEntry, fixture, () => buildClaudeContentWithToolCallsResponse(response.content ?? "", functionToolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks), jsonOpts(servedPayloadLength(response, effReasoning)));
+		else {
 			const events = buildClaudeContentWithToolCallsStreamEvents(response.content ?? "", functionToolCalls, completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking, response.blocks);
-			const interruption = createInterruptionSignal(fixture);
-			if (!await writeClaudeSSEStream(res, events, {
-				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();
+			await deliverStream(res, journalEntry, fixture, typedSseCodec(), events, streamTiming);
 		}
 		return;
 	}
 	if (isTextResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Claude Messages API — ignoring");
 		const overrides = extractOverrides(response);
-		const effectiveStrict = resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, defaults.logger);
 		const { reasoningSignature: effReasoningSignature, redactedThinking: effRedactedThinking } = resolveReasoningArtifactsForModel(response.reasoningSignature, response.redactedThinking, completionReq.model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
@@ -1344,33 +1406,18 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			defaults,
 			testId
 		});
-		if (claudeReq.stream !== true) {
-			const body = buildClaudeTextResponse(response.content, completionReq.model, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
+		rejectGeneratedFiles(response, "Anthropic Messages");
+		if (claudeReq.stream !== true) await deliverJson(res, journalEntry, fixture, () => buildClaudeTextResponse(response.content, completionReq.model, effReasoning, overrides, effReasoningSignature, effRedactedThinking), jsonOpts(servedPayloadLength(response, effReasoning)));
+		else {
 			const events = buildClaudeTextStreamEvents(response.content, completionReq.model, chunkSize, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
-			const interruption = createInterruptionSignal(fixture);
-			if (!await writeClaudeSSEStream(res, events, {
-				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();
+			await deliverStream(res, journalEntry, fixture, typedSseCodec(), events, streamTiming);
 		}
 		return;
 	}
 	if (isToolCallResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Claude Messages API — ignoring");
 		const overrides = extractOverrides(response);
-		const effectiveStrict = resolveStrictMode(defaults.strict, req.headers);
+		const effectiveStrict = resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression;
 		const effReasoning = resolveReasoningForModel(response.reasoning, completionReq.model, effectiveStrict, defaults.logger);
 		const { reasoningSignature: effReasoningSignature, redactedThinking: effRedactedThinking } = resolveReasoningArtifactsForModel(response.reasoningSignature, response.redactedThinking, completionReq.model, effectiveStrict, defaults.logger);
 		const journalEntry = journal.add({
@@ -1389,27 +1436,12 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 			defaults,
 			testId
 		});
+		rejectGeneratedFiles(response, "Anthropic Messages");
 		const functionToolCalls = requireEmittedFunctionToolCalls(response, "Anthropic Messages");
-		if (claudeReq.stream !== true) {
-			const body = buildClaudeToolCallResponse(functionToolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
-			res.writeHead(200, { "Content-Type": "application/json" });
-			res.end(JSON.stringify(body));
-		} else {
+		if (claudeReq.stream !== true) await deliverJson(res, journalEntry, fixture, () => buildClaudeToolCallResponse(functionToolCalls, completionReq.model, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking), jsonOpts(servedPayloadLength(response, effReasoning)));
+		else {
 			const events = buildClaudeToolCallStreamEvents(functionToolCalls, completionReq.model, chunkSize, logger, effReasoning, overrides, effReasoningSignature, effRedactedThinking);
-			const interruption = createInterruptionSignal(fixture);
-			if (!await writeClaudeSSEStream(res, events, {
-				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();
+			await deliverStream(res, journalEntry, fixture, typedSseCodec(), events, streamTiming);
 		}
 		return;
 	}
@@ -1428,12 +1460,12 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		defaults,
 		testId
 	});
-	writeErrorResponse(res, 500, JSON.stringify({ error: {
+	writeErrorResponse(res, 500, renderError("messages", "unknown-response", {
 		message: "Fixture response did not match any known type",
 		type: "server_error"
-	} }));
+	}).body);
 }
 
 //#endregion
-export { handleMessages, prepareClaudeMisbehavior };
+export { claudeToCompletionRequest, handleMessages, prepareClaudeMisbehavior };
 //# sourceMappingURL=messages.js.map