@copilotkit/aimock 1.38.0 → 1.40.0

package/dist/recorder.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.cts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAkMiB,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":";;;;;;;;;;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"}

package/dist/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","names":[],"sources":["../src/recorder.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAkMiB,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":";;;;;;;;;;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"}

package/dist/recorder.js

@@ -354,6 +354,8 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		if (collapsed.truncated) defaults.logger.warn("Bedrock EventStream: CRC mismatch — response may be truncated");
 		if (collapsed.droppedChunks && collapsed.droppedChunks > 0) defaults.logger.warn(`${collapsed.droppedChunks} chunk(s) dropped during stream collapse${collapsed.firstDroppedSample ? ` — first: ${collapsed.firstDroppedSample}` : ""}`);
 		if (collapsed.harmonyUnparsed) defaults.logger.warn(`Harmony tokens present but unparseable — content preserved verbatim${collapsed.harmonyNote ? ` (${collapsed.harmonyNote})` : ""}`);
+		const collapsedUsage = sanitizeRecordedUsage(collapsed.usage);
+		const usageSpread = collapsedUsage ? { usage: collapsedUsage } : {};
 		if (collapsed.transcription) fixtureResponse = { transcription: collapsed.transcription };
 		else if (collapsed.audioB64) {
 			const audioToolCallsSpread = collapsed.toolCalls && collapsed.toolCalls.length > 0 ? { toolCalls: collapsed.toolCalls.map((tc) => ({
@@ -384,7 +386,8 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 				...reasoningSpread,
 				...reasoningSignatureSpread,
 				...redactedThinkingSpread,
-				...webSearchesSpread
+				...webSearchesSpread,
+				...usageSpread
 			};
 		} else {
 			const reasoningSpread = collapsed.reasoning ? { reasoning: collapsed.reasoning } : {};
@@ -407,21 +410,24 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 						...reasoningSpread,
 						...reasoningSignatureSpread,
 						...redactedThinkingSpread,
-						...webSearchesSpread
+						...webSearchesSpread,
+						...usageSpread
 					};
 				} else fixtureResponse = {
 					toolCalls: sanitizedToolCalls,
 					...reasoningSpread,
 					...reasoningSignatureSpread,
 					...redactedThinkingSpread,
-					...webSearchesSpread
+					...webSearchesSpread,
+					...usageSpread
 				};
 			} else fixtureResponse = {
 				content: collapsed.content ?? "",
 				...reasoningSpread,
 				...reasoningSignatureSpread,
 				...redactedThinkingSpread,
-				...webSearchesSpread
+				...webSearchesSpread,
+				...usageSpread
 			};
 		}
 	} else {
@@ -771,6 +777,63 @@ function toToolCallArguments(raw) {
 	return JSON.stringify(raw);
 }
 /**
+* `usage` sub-objects that carry numeric breakdowns rather than a scalar. The
+* inner fields are NOT allowlisted here on purpose: the recorder keeps every
+* finite-numeric inner field (documented or forward-compat), matching the
+* load-time validator in fixture-loader.ts, whose index-signature escape hatch
+* accepts undocumented numeric inner keys too. A `Set` (own-key membership via
+* `.has()`, no prototype-chain walk) mirrors that validator's
+* `new Set(Object.keys(...))` classification so anything this recorder writes
+* loads cleanly.
+*/
+const USAGE_OBJECT_FIELDS = new Set([
+	"cost_details",
+	"prompt_tokens_details",
+	"completion_tokens_details"
+]);
+/**
+* Sanitize a provider-reported `usage` object into the fixture
+* `response.usage` override shape (#368).
+*
+* The recorder persists real upstream usage so replay can serve the provider's
+* ACTUAL token counts (instead of the `ceil(len/4)` estimate) and OpenRouter's
+* `cost` — which previously never survived recording at all. Upstream usage is
+* provider-specific and forward-extending, so this passes fields through rather
+* than whitelisting them, but only in the shapes the fixture contract accepts:
+*
+* - numeric scalars (`prompt_tokens`, `cost`, `native_tokens_prompt`, …) — kept
+* - `is_byok` boolean — kept
+* - the documented breakdown objects — kept, with non-numeric inner fields
+*   dropped (the load-time validator rejects those, and a fixture the recorder
+*   writes must always load)
+* - anything else (strings, arrays, nulls, unknown objects) — DROPPED, because
+*   `fixture-loader.ts` errors on a non-numeric extra `usage` key and a recorded
+*   fixture that fails validation is worse than one missing an exotic field
+*
+* Returns `undefined` when nothing survives, so the caller omits `usage`
+* entirely and keeps pre-#368 fixtures byte-identical.
+*/
+function sanitizeRecordedUsage(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const out = {};
+	for (const [key, val] of Object.entries(raw)) {
+		if (val === void 0 || val === null) continue;
+		if (USAGE_OBJECT_FIELDS.has(key)) {
+			if (typeof val !== "object" || val === null || Array.isArray(val)) continue;
+			const inner = {};
+			for (const [innerKey, innerVal] of Object.entries(val)) if (typeof innerVal === "number" && Number.isFinite(innerVal)) inner[innerKey] = innerVal;
+			if (Object.keys(inner).length > 0) out[key] = inner;
+			continue;
+		}
+		if (key === "is_byok") {
+			if (typeof val === "boolean") out[key] = val;
+			continue;
+		}
+		if (typeof val === "number" && Number.isFinite(val)) out[key] = val;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/**
 * Detect the response format from the parsed upstream JSON and convert
 * it into an aimock FixtureResponse.
 */
@@ -877,6 +940,8 @@ function buildFixtureResponse(parsed, status, logger, request) {
 			const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
 			const hasContent = typeof message.content === "string" && message.content.length > 0;
 			const openaiReasoning = typeof message.reasoning_content === "string" && message.reasoning_content.length > 0 ? message.reasoning_content : typeof message.reasoning === "string" && message.reasoning.length > 0 ? message.reasoning : void 0;
+			const openaiUsage = sanitizeRecordedUsage(obj.usage);
+			const usageSpread = openaiUsage ? { usage: openaiUsage } : {};
 			if (hasToolCalls) {
 				const toolCalls = message.tool_calls.map((tc) => {
 					const fn = tc.function;
@@ -889,20 +954,24 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				if (hasContent) return {
 					content: message.content,
 					toolCalls,
-					...openaiReasoning ? { reasoning: openaiReasoning } : {}
+					...openaiReasoning ? { reasoning: openaiReasoning } : {},
+					...usageSpread
 				};
 				return {
 					toolCalls,
-					...openaiReasoning ? { reasoning: openaiReasoning } : {}
+					...openaiReasoning ? { reasoning: openaiReasoning } : {},
+					...usageSpread
 				};
 			}
 			if (hasContent) return {
 				content: message.content,
-				...openaiReasoning ? { reasoning: openaiReasoning } : {}
+				...openaiReasoning ? { reasoning: openaiReasoning } : {},
+				...usageSpread
 			};
 			return {
 				content: "",
-				...openaiReasoning ? { reasoning: openaiReasoning } : {}
+				...openaiReasoning ? { reasoning: openaiReasoning } : {},
+				...usageSpread
 			};
 		}
 	}