@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/recorder.cjs

@@ -229,7 +229,15 @@ function persistFixture(opts) {
 			const existing = JSON.parse(node_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] };
+			const keptKeys = {};
+			if (existing !== null && typeof existing === "object" && !Array.isArray(existing)) for (const [key, value] of Object.entries(existing)) {
+				if (key === "fixtures" || key === "_warnings" || key === "_warning") continue;
+				keptKeys[key] = value;
+			}
+			fileContent = {
+				...keptKeys,
+				fixtures: [...existingFixtures ?? [], fixture]
+			};
 			if (Array.isArray(existing._warnings)) fileWarnings.unshift(...existing._warnings.filter((w) => typeof w === "string"));
 			else if (typeof existing._warning === "string" && existing._warning) fileWarnings.unshift(...existing._warning.split("; "));
 		} catch (mergeErr) {
@@ -378,7 +386,8 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 	const contentType = upstreamHeaders["content-type"];
 	const ctString = pickContentType(contentType);
 	const isBinaryStream = ctString.toLowerCase().includes("application/vnd.amazon.eventstream");
-	const collapsed = require_stream_collapse.collapseStreamingResponse(ctString, providerKey, isBinaryStream ? rawBuffer : upstreamBody, defaults.logger);
+	const collapsedRaw = require_stream_collapse.collapseStreamingResponseWithResponsesTools(ctString, providerKey, isBinaryStream ? rawBuffer : upstreamBody, defaults.logger);
+	const collapsed = collapsedRaw && defaults.responsesTools !== "extended" ? require_stream_collapse.withoutResponsesToolFields(collapsedRaw) : collapsedRaw;
 	let fixtureResponse;
 	if (ctString.toLowerCase().startsWith("audio/") && upstreamStatus >= 200 && upstreamStatus < 300) {
 		const audioFormat = ctString.toLowerCase().replace("audio/", "").replace("mpeg", "mp3").split(";")[0].trim();
@@ -412,7 +421,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 				...audioContentSpread,
 				...audioReasoningSpread
 			};
-		} else if (collapsed.content === "" && (!collapsed.toolCalls || collapsed.toolCalls.length === 0)) {
+		} else if (collapsed.content === "" && (!collapsed.toolCalls || collapsed.toolCalls.length === 0) && !collapsed.customToolCalls?.length) {
 			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 } : {};
@@ -433,12 +442,27 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 			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) => ({
+			if (collapsed.customToolCalls?.length) {
+				const toolCalls = (collapsed.toolCalls ?? []).map(sanitizeRecordedToolCall);
+				const customToolCalls = collapsed.customToolCalls.map((tc) => ({
 					...tc,
 					name: tc.name ?? "",
-					arguments: tc.arguments ?? "{}"
+					input: tc.input ?? ""
 				}));
+				const orderSpread = collapsed.responsesBlocks?.length ? { responsesBlocks: collapsed.responsesBlocks } : collapsed.blocks?.length ? { blocks: collapsed.blocks } : {};
+				fixtureResponse = {
+					...collapsed.content ? { content: collapsed.content } : {},
+					toolCalls,
+					customToolCalls,
+					...orderSpread,
+					...reasoningSpread,
+					...reasoningSignatureSpread,
+					...redactedThinkingSpread,
+					...webSearchesSpread,
+					...usageSpread
+				};
+			} else if (collapsed.toolCalls && collapsed.toolCalls.length > 0) {
+				const sanitizedToolCalls = collapsed.toolCalls.map(sanitizeRecordedToolCall);
 				if (collapsed.content) {
 					const blocksSpread = collapsed.blocks?.length ? { blocks: collapsed.blocks } : {};
 					fixtureResponse = {
@@ -801,6 +825,14 @@ function makeUpstreamRequest(target, headers, body, clientRes, method = "POST",
 function logDroppedReasoningSignature(logger, reasoning, reasoningSignature) {
 	if (reasoningSignature && !reasoning) logger?.warn("Dropping captured reasoningSignature — no plaintext reasoning to attach it to");
 }
+/** Sanitize a collapsed function call before it is persisted: string `name` and `arguments`. */
+function sanitizeRecordedToolCall(tc) {
+	return {
+		...tc,
+		name: tc.name ?? "",
+		arguments: tc.arguments ?? "{}"
+	};
+}
 /**
 * Coerce a tool call's `arguments` field into the string the fixture contract
 * requires (types.ts `ToolCall.arguments: string`). When the upstream omits the
@@ -1265,6 +1297,82 @@ function buildFixtureMetadata(request) {
 	if (request.tools && request.tools.length > 0) meta.toolsHash = node_crypto.createHash("sha256").update(JSON.stringify(request.tools)).digest("hex").slice(0, 8);
 	return Object.keys(meta).length > 0 ? meta : void 0;
 }
+/**
+* MR11: read-merge-validate-write one service fakes file atomically (temp +
+* rename, 0o600). Synchronous, so writes to one path never interleave in this
+* process. Keeps unknown top-level keys (fakes:F9). `validate` returns a
+* problem text, or null when the whole merged file is valid. Logs RL4 on a
+* write; a failure is returned, never logged here (the caller logs RL1 with
+* its own context).
+*/
+function persistServiceFakes(opts) {
+	const { filepath, merge, validate, logger } = opts;
+	let existing = null;
+	let text = null;
+	try {
+		text = node_fs.readFileSync(filepath, "utf-8");
+	} catch (err) {
+		if (err.code !== "ENOENT") return {
+			kind: "failed",
+			stage: "write",
+			error: err instanceof Error ? err.message : "Unknown filesystem error"
+		};
+	}
+	if (text !== null) {
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			return {
+				kind: "failed",
+				stage: "read",
+				error: `${filepath} is not valid JSON`
+			};
+		}
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {
+			kind: "failed",
+			stage: "read",
+			error: `${filepath} is not a JSON object`
+		};
+		existing = parsed;
+	}
+	const content = merge(existing);
+	const problem = validate(content);
+	if (problem !== null) return {
+		kind: "failed",
+		stage: "validate",
+		error: problem
+	};
+	let tmpPath;
+	try {
+		node_fs.mkdirSync(node_path.dirname(filepath), { recursive: true });
+		const bytes = Buffer.from(JSON.stringify(content, null, 2), "utf-8");
+		tmpPath = filepath + ".tmp." + node_crypto.randomUUID();
+		node_fs.writeFileSync(tmpPath, bytes, {
+			flag: "wx",
+			mode: 384
+		});
+		node_fs.renameSync(tmpPath, filepath);
+		tmpPath = void 0;
+		logger.warn(`Response recorded → ${filepath}`);
+		return {
+			kind: "written",
+			filepath,
+			sha256: node_crypto.createHash("sha256").update(bytes).digest("hex"),
+			content
+		};
+	} catch (err) {
+		return {
+			kind: "failed",
+			stage: "write",
+			error: err instanceof Error ? err.message : "Unknown filesystem error"
+		};
+	} finally {
+		if (tmpPath) try {
+			node_fs.unlinkSync(tmpPath);
+		} catch {}
+	}
+}
 
 //#endregion
 exports.DEFAULT_MAX_PROXY_BUFFER_BYTES = DEFAULT_MAX_PROXY_BUFFER_BYTES;
@@ -1274,6 +1382,7 @@ exports.buildFixtureMatch = buildFixtureMatch;
 exports.buildForwardHeaders = buildForwardHeaders;
 exports.clampTimeout = clampTimeout;
 exports.persistFixture = persistFixture;
+exports.persistServiceFakes = persistServiceFakes;
 exports.prepareEgressHeaders = prepareEgressHeaders;
 exports.proxyAndRecord = proxyAndRecord;
 exports.removeForwardHeader = removeForwardHeader;