@copilotkit/aimock 1.42.1 → 1.44.0

package/dist/recorder.d.cts.map

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

package/dist/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAmMiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA6MU,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":";;;;;;;;;;UAiOiB,qBAAA;;;QAGT;;UAGS,YAAA;;;;;;;;;;;;;;;;;;mCAkBkB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;KAuB3D,YAAA;;;;;;;;;;;;;;;iBA8OU,cAAA,MACf,MAAA,CAAK,sBACL,MAAA,CAAK,yBACD,oCACI,+CAEH;WAEC;UACD;2BACiB,0BAA0B;+BAG3C,eACT,QAAQ"}

package/dist/recorder.js

@@ -1,9 +1,9 @@
 import { DEFAULT_TEST_ID } from "./constants.js";
 import { normalizeModelName } from "./model-utils.js";
 import { isAuthenticatedRequest, isRecognizedApiKeyHeader } from "./api-key-auth.js";
-import { getTestId, slugifyContext, slugifyTestId } from "./helpers.js";
-import { currentTurnHasToolResult, getLastMessageByRole, getTextContent } from "./router.js";
+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 { resolveUpstreamUrl } from "./url.js";
 import { applyConfiguredProviderAuth, applyProviderAuth } from "./provider-auth.js";
@@ -98,9 +98,17 @@ const STRIP_HEADERS = new Set([
 	"x-aimock-context"
 ]);
 /**
+* Headers stripped on egress ONLY when aimock minted the value. A
+* caller-supplied `x-request-id` is the caller's own trace key and forwards
+* verbatim; the id aimock invents for its access log and journal is
+* meaningless on a real provider's wire and must not be transmitted.
+*/
+const MINTED_ONLY_STRIP_HEADERS = new Set(["x-request-id"]);
+/**
 * 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
+* headers (STRIP_HEADERS, plus the x-aimock-chaos-* prefix family, plus
+* MINTED_ONLY_STRIP_HEADERS when aimock minted the value). Shared
 * by the generic recorder proxy and the OpenRouter-video live lifecycle
 * proxy.
 */
@@ -108,7 +116,7 @@ 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-") || isAuthenticatedRequest(req) && isRecognizedApiKeyHeader(lower)) continue;
+		if (val === void 0 || STRIP_HEADERS.has(lower) || MINTED_ONLY_STRIP_HEADERS.has(lower) && hasMintedRequestId(req) || lower.startsWith("x-aimock-chaos-") || isAuthenticatedRequest(req) && isRecognizedApiKeyHeader(lower)) continue;
 		out[name] = Array.isArray(val) ? val.join(", ") : val;
 	}
 	return out;
@@ -119,6 +127,19 @@ function removeForwardHeader(headers, name) {
 	for (const key of Object.keys(headers)) if (key.toLowerCase() === lowerName) delete headers[key];
 }
 /**
+* Set a header on an egress map ONLY if the inbound request did not already
+* supply it (in any casing). Used for content-negotiation defaults the mock
+* wants when the caller was not explicit. Never overwrites: a caller-sent
+* header may be covered by a request signature (AWS SigV4 and friends sign a
+* named subset of headers), so replacing one silently invalidates the request
+* upstream.
+*/
+function setForwardHeaderDefault(headers, name, value) {
+	const lowerName = name.toLowerCase();
+	for (const key of Object.keys(headers)) if (key.toLowerCase() === lowerName) return;
+	headers[name] = value;
+}
+/**
 * Construct the only safe egress map when inbound access control is enabled.
 * Test credentials are always removed; a static configured provider credential
 * is mandatory so an accepted test credential can never become an upstream one.
@@ -166,6 +187,7 @@ function pickContentType(contentType) {
 */
 function persistFixture(opts) {
 	const { record, providerKey, testId, fixture, fixtures, warnings = [], logger } = opts;
+	const fileKey = opts.filePrefix ?? providerKey;
 	const m = fixture.match;
 	const isEmptyMatch = m.userMessage === void 0 && m.inputText === void 0 && m.endpoint === void 0;
 	if (record.proxyOnly) {
@@ -182,17 +204,18 @@ function persistFixture(opts) {
 		if (!slug) {
 			isSnapshotMode = false;
 			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-			filepath = path.join(fixturePath, `${providerKey}-${timestamp}-${crypto$1.randomUUID().slice(0, 8)}.json`);
+			filepath = path.join(fixturePath, `${fileKey}-${timestamp}-${crypto$1.randomUUID().slice(0, 8)}.json`);
 		} else {
-			filepath = path.join(fixturePath, slug, `${providerKey}.json`);
+			filepath = path.join(fixturePath, slug, `${fileKey}.json`);
 			mergeExisting = true;
 		}
 	} else {
-		const timestampFile = `${providerKey}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${crypto$1.randomUUID().slice(0, 8)}.json`;
+		const timestampFile = `${fileKey}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${crypto$1.randomUUID().slice(0, 8)}.json`;
 		const contextSegment = fixture.match.context ? slugifyContext(fixture.match.context) : void 0;
 		filepath = contextSegment ? path.join(fixturePath, contextSegment, timestampFile) : path.join(fixturePath, timestampFile);
 	}
 	const fileWarnings = [...isEmptyMatch ? ["Empty match criteria — this fixture will not match any request"] : [], ...warnings];
+	let tmpPath;
 	try {
 		fs.mkdirSync(path.dirname(filepath), { recursive: true });
 		let fileContent;
@@ -200,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) {
@@ -214,9 +245,14 @@ function persistFixture(opts) {
 			fileContent._warnings = dedupedWarnings;
 			fileContent._warning = dedupedWarnings.join("; ");
 		}
-		const tmpPath = filepath + ".tmp." + process.pid;
-		fs.writeFileSync(tmpPath, JSON.stringify(fileContent, null, 2), "utf-8");
+		tmpPath = filepath + ".tmp." + crypto$1.randomUUID();
+		fs.writeFileSync(tmpPath, JSON.stringify(fileContent, null, 2), {
+			encoding: "utf-8",
+			flag: "wx",
+			mode: 384
+		});
 		fs.renameSync(tmpPath, filepath);
+		tmpPath = void 0;
 		if (!isEmptyMatch) fixtures.push(fixture);
 		logger.warn(`Response recorded → ${filepath}`);
 		return {
@@ -230,6 +266,10 @@ function persistFixture(opts) {
 			kind: "failed",
 			error: msg
 		};
+	} finally {
+		if (tmpPath) try {
+			fs.unlinkSync(tmpPath);
+		} catch {}
 	}
 }
 /**
@@ -438,7 +478,7 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 			const msg = parseErr instanceof Error ? parseErr.message : "unknown";
 			defaults.logger.warn(`Upstream response is not valid JSON (${msg}) — saving as error fixture`);
 		}
-		if (request._endpointType === "fal" && parsedResponse !== null) {
+		if ((request._endpointType === "fal" || request._endpointType === "elevenlabs-voice-design" || request._endpointType === "elevenlabs-voice" || request._endpointType === "elevenlabs-voice-get" || request._endpointType === "elevenlabs-voice-delete") && parsedResponse !== null) {
 			const obj = parsedResponse;
 			if (typeof obj.error === "object" && obj.error !== null && typeof obj.error.message === "string") {
 				const err = obj.error;
@@ -1229,5 +1269,5 @@ function buildFixtureMetadata(request) {
 }
 
 //#endregion
-export { buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, prepareEgressHeaders, proxyAndRecord, removeForwardHeader, sanitizeHeaderValue };
+export { DEFAULT_MAX_PROXY_BUFFER_BYTES, DEFAULT_MAX_PROXY_BUFFER_FRAMES, PROXY_BUFFER_HARD_CEILING, buildFixtureMatch, buildForwardHeaders, clampTimeout, persistFixture, prepareEgressHeaders, proxyAndRecord, removeForwardHeader, sanitizeHeaderValue, setForwardHeaderDefault };
 //# sourceMappingURL=recorder.js.map