@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/recorder.d.cts

@@ -1,5 +1,5 @@
 import { Logger } from "./logger.cjs";
-import { ChatCompletionRequest, Fixture, RecordConfig, RecordProviderKey } from "./types.cjs";
+import { ChatCompletionRequest, Fixture, RecordConfig, RecordProviderKey, ResponsesToolsMode } from "./types.cjs";
 import * as http$1 from "node:http";
 
 //#region src/recorder.d.ts
@@ -72,6 +72,7 @@ declare function proxyAndRecord(req: http$1.IncomingMessage, res: http$1.ServerR
   record?: RecordConfig;
   logger: Logger;
   requestTransform?: (req: ChatCompletionRequest) => ChatCompletionRequest;
+  responsesTools?: ResponsesToolsMode;
 }, rawBody?: string, options?: ProxyOptions): Promise<ProxyOutcome>;
 /**
  * Decodes a sequence of byte chunks to UTF-8 text for SSE/NDJSON frame

package/dist/recorder.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.cts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAiOiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA8NU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}
+{"version":3,"file":"recorder.d.cts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAsOiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA8OU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;mBAClC;+BAGT,eACT,QAAQ"}

package/dist/recorder.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from "./logger.js";
-import { ChatCompletionRequest, Fixture, RecordConfig, RecordProviderKey } from "./types.js";
+import { ChatCompletionRequest, Fixture, RecordConfig, RecordProviderKey, ResponsesToolsMode } from "./types.js";
 import * as http$1 from "node:http";
 
 //#region src/recorder.d.ts
@@ -72,6 +72,7 @@ declare function proxyAndRecord(req: http$1.IncomingMessage, res: http$1.ServerR
   record?: RecordConfig;
   logger: Logger;
   requestTransform?: (req: ChatCompletionRequest) => ChatCompletionRequest;
+  responsesTools?: ResponsesToolsMode;
 }, rawBody?: string, options?: ProxyOptions): Promise<ProxyOutcome>;
 /**
  * Decodes a sequence of byte chunks to UTF-8 text for SSE/NDJSON frame

package/dist/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAiOiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA8NU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}
+{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAsOiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA8OU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;mBAClC;+BAGT,eACT,QAAQ"}

package/dist/recorder.js

@@ -4,7 +4,7 @@ import { isAuthenticatedRequest, isRecognizedApiKeyHeader } from "./api-key-auth
 import { getTestId, hasMintedRequestId, slugifyContext, slugifyTestId } from "./helpers.js";
 import { writeErrorResponse } from "./sse-writer.js";
 import { currentTurnHasToolResult, getLastMessageByRole, getTextContent } from "./router.js";
-import { capturedRedactedData, collapseStreamingResponse } from "./stream-collapse.js";
+import { capturedRedactedData, collapseStreamingResponseWithResponsesTools, withoutResponsesToolFields } from "./stream-collapse.js";
 import { resolveUpstreamUrl } from "./url.js";
 import { applyConfiguredProviderAuth, applyProviderAuth } from "./provider-auth.js";
 import * as http$1 from "node:http";
@@ -223,7 +223,15 @@ function persistFixture(opts) {
 			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] };
+			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) {
@@ -372,7 +380,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 = collapseStreamingResponse(ctString, providerKey, isBinaryStream ? rawBuffer : upstreamBody, defaults.logger);
+	const collapsedRaw = collapseStreamingResponseWithResponsesTools(ctString, providerKey, isBinaryStream ? rawBuffer : upstreamBody, defaults.logger);
+	const collapsed = collapsedRaw && defaults.responsesTools !== "extended" ? 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();
@@ -406,7 +415,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 } : {};
@@ -427,12 +436,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 = {
@@ -795,6 +819,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
@@ -1259,7 +1291,83 @@ function buildFixtureMetadata(request) {
 	if (request.tools && request.tools.length > 0) meta.toolsHash = crypto$1.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 = 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 {
+		fs.mkdirSync(path.dirname(filepath), { recursive: true });
+		const bytes = Buffer.from(JSON.stringify(content, null, 2), "utf-8");
+		tmpPath = filepath + ".tmp." + crypto$1.randomUUID();
+		fs.writeFileSync(tmpPath, bytes, {
+			flag: "wx",
+			mode: 384
+		});
+		fs.renameSync(tmpPath, filepath);
+		tmpPath = void 0;
+		logger.warn(`Response recorded → ${filepath}`);
+		return {
+			kind: "written",
+			filepath,
+			sha256: crypto$1.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 {
+			fs.unlinkSync(tmpPath);
+		} catch {}
+	}
+}
 
 //#endregion
-export { DEFAULT_MAX_PROXY_BUFFER_BYTES, DEFAULT_MAX_PROXY_BUFFER_FRAMES, PROXY_BUFFER_HARD_CEILING, buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, prepareEgressHeaders, proxyAndRecord, removeForwardHeader, sanitizeHeaderValue, setForwardHeaderDefault };
+export { DEFAULT_MAX_PROXY_BUFFER_BYTES, DEFAULT_MAX_PROXY_BUFFER_FRAMES, PROXY_BUFFER_HARD_CEILING, buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, persistServiceFakes, prepareEgressHeaders, proxyAndRecord, removeForwardHeader, sanitizeHeaderValue, setForwardHeaderDefault };
 //# sourceMappingURL=recorder.js.map