@copilotkit/aimock 1.29.0 → 1.31.0

package/dist/recorder.js

@@ -1,9 +1,9 @@
 import { DEFAULT_TEST_ID } from "./constants.js";
+import { normalizeModelName } from "./model-utils.js";
 import { getTestId, slugifyTestId } from "./helpers.js";
 import { getLastMessageByRole, getTextContent } from "./router.js";
 import { writeErrorResponse } from "./sse-writer.js";
-import { normalizeModelName } from "./model-utils.js";
-import { collapseStreamingResponse } from "./stream-collapse.js";
+import { capturedRedactedData, collapseStreamingResponse } from "./stream-collapse.js";
 import { resolveUpstreamUrl } from "./url.js";
 import * as http$1 from "node:http";
 import * as crypto$1 from "node:crypto";
@@ -26,9 +26,39 @@ const STRIP_HEADERS = new Set([
 	"host",
 	"content-length",
 	"cookie",
-	"accept-encoding"
+	"accept-encoding",
+	"x-test-id",
+	"x-aimock-strict",
+	"x-aimock-context"
 ]);
 /**
+* Build the header set forwarded to an upstream provider from an incoming
+* request: everything except hop-by-hop, client-set, and mock-internal
+* headers (STRIP_HEADERS, plus the x-aimock-chaos-* prefix family). Shared
+* by the generic recorder proxy and the OpenRouter-video live lifecycle
+* proxy.
+*/
+function buildForwardHeaders(req) {
+	const out = {};
+	for (const [name, val] of Object.entries(req.headers)) {
+		const lower = name.toLowerCase();
+		if (val === void 0 || STRIP_HEADERS.has(lower) || lower.startsWith("x-aimock-chaos-")) continue;
+		out[name] = Array.isArray(val) ? val.join(", ") : val;
+	}
+	return out;
+}
+/**
+* Make an arbitrary string safe to set as an HTTP header value. Node's
+* `res.setHeader` throws ERR_INVALID_CHAR on anything outside Latin-1 (plus
+* control characters) — and persist errors embed filesystem paths verbatim,
+* so a Unicode fixture path would turn a recoverable record failure into a
+* 500. Out-of-range characters are replaced with `?` rather than stripped so
+* the value's shape stays legible.
+*/
+function sanitizeHeaderValue(value) {
+	return value.replace(/[^\t\x20-\x7e\x80-\xff]/g, "?");
+}
+/**
 * Write a built fixture to disk (snapshot vs. timestamp file layout) and, when
 * the match is non-empty, register it in the in-memory cache so subsequent
 * identical requests match. Extracted from `proxyAndRecord` so the fal
@@ -40,11 +70,11 @@ function persistFixture(opts) {
 	const { record, providerKey, testId, fixture, fixtures, warnings = [], logger } = opts;
 	const m = fixture.match;
 	const isEmptyMatch = m.userMessage === void 0 && m.inputText === void 0 && m.endpoint === void 0;
-	if (isEmptyMatch) logger.warn("Recorded fixture has empty match criteria — skipping in-memory registration");
 	if (record.proxyOnly) {
 		logger.info(`Proxied ${providerKey} request (proxy-only mode)`);
 		return { kind: "skipped" };
 	}
+	if (isEmptyMatch) logger.warn("Recorded fixture has empty match criteria — skipping in-memory registration");
 	const fixturePath = record.fixturePath ?? "./fixtures/recorded";
 	let isSnapshotMode = testId !== DEFAULT_TEST_ID;
 	let filepath;
@@ -68,14 +98,18 @@ function persistFixture(opts) {
 		fs.mkdirSync(path.dirname(filepath), { recursive: true });
 		let fileContent;
 		if (mergeExisting && fs.existsSync(filepath)) try {
-			fileContent = { fixtures: [...JSON.parse(fs.readFileSync(filepath, "utf-8")).fixtures ?? [], fixture] };
+			const existing = JSON.parse(fs.readFileSync(filepath, "utf-8"));
+			const existingFixtures = Array.isArray(existing.fixtures) ? existing.fixtures : void 0;
+			if (existingFixtures === void 0 && existing.fixtures !== void 0) logger.warn(`Existing fixture file ${filepath} has a non-array "fixtures" — discarding it and starting fresh`);
+			fileContent = { fixtures: [...existingFixtures ?? [], fixture] };
+			if (typeof existing._warning === "string" && existing._warning) fileWarnings.unshift(...existing._warning.split("; "));
 		} catch (mergeErr) {
 			const msg = mergeErr instanceof Error ? mergeErr.message : "unknown";
 			logger.warn(`Could not read existing fixture file ${filepath} (${msg}) — overwriting`);
 			fileContent = { fixtures: [fixture] };
 		}
 		else fileContent = { fixtures: [fixture] };
-		if (fileWarnings.length > 0) fileContent._warning = fileWarnings.join("; ");
+		if (fileWarnings.length > 0) fileContent._warning = [...new Set(fileWarnings)].join("; ");
 		const tmpPath = filepath + ".tmp." + process.pid;
 		fs.writeFileSync(tmpPath, JSON.stringify(fileContent, null, 2), "utf-8");
 		fs.renameSync(tmpPath, filepath);
@@ -120,8 +154,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		return "relayed";
 	}
 	defaults.logger.warn(`NO FIXTURE MATCH — proxying to ${upstreamUrl}${pathname}`);
-	const forwardHeaders = {};
-	for (const [name, val] of Object.entries(req.headers)) if (val !== void 0 && !STRIP_HEADERS.has(name)) forwardHeaders[name] = Array.isArray(val) ? val.join(", ") : val;
+	const forwardHeaders = buildForwardHeaders(req);
 	const requestBody = rawBody ?? JSON.stringify(request);
 	let upstreamStatus;
 	let upstreamHeaders;
@@ -192,14 +225,22 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		} else if (collapsed.content === "" && (!collapsed.toolCalls || collapsed.toolCalls.length === 0)) {
 			defaults.logger.warn("Stream collapse produced empty content — fixture may be incomplete");
 			const reasoningSpread = collapsed.reasoning ? { reasoning: collapsed.reasoning } : {};
+			const reasoningSignatureSpread = collapsed.reasoning && collapsed.reasoningSignature ? { reasoningSignature: collapsed.reasoningSignature } : {};
+			logDroppedReasoningSignature(defaults.logger, collapsed.reasoning, collapsed.reasoningSignature);
+			const redactedThinkingSpread = collapsed.redactedThinking?.length ? { redactedThinking: collapsed.redactedThinking } : {};
 			const webSearchesSpread = collapsed.webSearches?.length ? { webSearches: collapsed.webSearches } : {};
 			fixtureResponse = {
 				content: collapsed.content ?? "",
 				...reasoningSpread,
+				...reasoningSignatureSpread,
+				...redactedThinkingSpread,
 				...webSearchesSpread
 			};
 		} else {
 			const reasoningSpread = collapsed.reasoning ? { reasoning: collapsed.reasoning } : {};
+			const reasoningSignatureSpread = collapsed.reasoning && collapsed.reasoningSignature ? { reasoningSignature: collapsed.reasoningSignature } : {};
+			logDroppedReasoningSignature(defaults.logger, collapsed.reasoning, collapsed.reasoningSignature);
+			const redactedThinkingSpread = collapsed.redactedThinking?.length ? { redactedThinking: collapsed.redactedThinking } : {};
 			const webSearchesSpread = collapsed.webSearches?.length ? { webSearches: collapsed.webSearches } : {};
 			if (collapsed.toolCalls && collapsed.toolCalls.length > 0) {
 				const sanitizedToolCalls = collapsed.toolCalls.map((tc) => ({
@@ -211,16 +252,22 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 					content: collapsed.content,
 					toolCalls: sanitizedToolCalls,
 					...reasoningSpread,
+					...reasoningSignatureSpread,
+					...redactedThinkingSpread,
 					...webSearchesSpread
 				};
 				else fixtureResponse = {
 					toolCalls: sanitizedToolCalls,
 					...reasoningSpread,
+					...reasoningSignatureSpread,
+					...redactedThinkingSpread,
 					...webSearchesSpread
 				};
 			} else fixtureResponse = {
 				content: collapsed.content ?? "",
 				...reasoningSpread,
+				...reasoningSignatureSpread,
+				...redactedThinkingSpread,
 				...webSearchesSpread
 			};
 		}
@@ -255,7 +302,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 			} catch (err) {
 				defaults.logger.debug(`Could not parse encoding_format from raw body: ${err instanceof Error ? err.message : "unknown error"}`);
 			}
-			fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, encodingFormat);
+			fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, encodingFormat, defaults.logger);
 		}
 	}
 	if (clientDisconnected) {
@@ -291,7 +338,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		logger: defaults.logger
 	});
 	if (persistResult.kind === "failed") {
-		if (!res.headersSent) res.setHeader("X-AIMock-Record-Error", persistResult.error);
+		if (!res.headersSent) res.setHeader("X-AIMock-Record-Error", sanitizeHeaderValue(persistResult.error));
 		else defaults.logger.warn(`Cannot set X-AIMock-Record-Error header — headers already sent`);
 		defaults.logger.warn(`Response relayed but NOT saved to disk — see error above`);
 	}
@@ -348,6 +395,11 @@ var StreamingFrameDecoder = class {
 		return this.decoder.end();
 	}
 };
+/**
+* Sanitize a configured timeout: non-finite or non-positive values fall back
+* to the default. Shared with the OpenRouter-video live lifecycle proxy so
+* `record.upstreamTimeoutMs` is clamped identically on every proxy path.
+*/
 function clampTimeout(value, fallback) {
 	if (value == null || !Number.isFinite(value) || value <= 0) return fallback;
 	return value;
@@ -461,10 +513,19 @@ function makeUpstreamRequest(target, headers, body, clientRes, method = "POST",
 	});
 }
 /**
+* A captured Anthropic thinking-block signature is only persisted alongside
+* non-empty plaintext `reasoning` (a bare signature has nothing to attach to on
+* replay). When that gate drops a present signature, warn so the loss is
+* observable (matching the recording-side anomaly convention in this file).
+*/
+function logDroppedReasoningSignature(logger, reasoning, reasoningSignature) {
+	if (reasoningSignature && !reasoning) logger?.warn("Dropping captured reasoningSignature — no plaintext reasoning to attach it to");
+}
+/**
 * Detect the response format from the parsed upstream JSON and convert
 * it into an aimock FixtureResponse.
 */
-function buildFixtureResponse(parsed, status, encodingFormat) {
+function buildFixtureResponse(parsed, status, encodingFormat, logger) {
 	if (parsed === null || parsed === void 0) return {
 		error: {
 			message: "Upstream returned non-JSON response",
@@ -593,10 +654,20 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 		const toolUseBlocks = blocks.filter((b) => b.type === "tool_use");
 		const textBlocks = blocks.filter((b) => b.type === "text" && typeof b.text === "string");
 		const thinkingBlocks = blocks.filter((b) => b.type === "thinking");
+		const redactedBlocks = blocks.filter((b) => b.type === "redacted_thinking");
+		const redactedThinking = blocks.map((b) => capturedRedactedData(b)).filter((data) => data !== void 0);
 		const hasToolCalls = toolUseBlocks.length > 0;
 		const joinedText = textBlocks.map((b) => String(b.text ?? "")).join("");
 		const hasContent = joinedText.length > 0;
 		const anthropicReasoning = thinkingBlocks.length > 0 ? thinkingBlocks.map((b) => String(b.thinking ?? "")).join("") : void 0;
+		const anthropicReasoningSignature = (() => {
+			let sig;
+			for (const b of thinkingBlocks) if (typeof b.signature === "string") sig = String(b.signature);
+			return sig;
+		})();
+		const reasoningSignatureSpread = anthropicReasoning && anthropicReasoningSignature ? { reasoningSignature: anthropicReasoningSignature } : {};
+		logDroppedReasoningSignature(logger, anthropicReasoning, anthropicReasoningSignature);
+		const redactedThinkingSpread = redactedThinking.length > 0 ? { redactedThinking } : {};
 		if (hasToolCalls) {
 			const toolCalls = toolUseBlocks.map((b) => ({
 				name: String(b.name),
@@ -606,20 +677,28 @@ function buildFixtureResponse(parsed, status, encodingFormat) {
 			if (hasContent) return {
 				content: joinedText,
 				toolCalls,
-				...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+				...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
+				...reasoningSignatureSpread,
+				...redactedThinkingSpread
 			};
 			return {
 				toolCalls,
-				...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+				...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
+				...reasoningSignatureSpread,
+				...redactedThinkingSpread
 			};
 		}
 		if (hasContent) return {
 			content: joinedText,
-			...anthropicReasoning ? { reasoning: anthropicReasoning } : {}
+			...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
+			...reasoningSignatureSpread,
+			...redactedThinkingSpread
 		};
-		if (anthropicReasoning) return {
+		if (thinkingBlocks.length > 0 || redactedBlocks.length > 0) return {
 			content: "",
-			reasoning: anthropicReasoning
+			...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
+			...reasoningSignatureSpread,
+			...redactedThinkingSpread
 		};
 	}
 	if (Array.isArray(obj.candidates) && obj.candidates.length > 0) {
@@ -816,5 +895,5 @@ function buildFixtureMetadata(request) {
 }
 
 //#endregion
-export { buildFixtureMatch, persistFixture, proxyAndRecord };
+export { buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, proxyAndRecord, sanitizeHeaderValue };
 //# sourceMappingURL=recorder.js.map