@copilotkit/aimock 1.45.1 → 1.46.0

package/dist/recorder.d.cts.map

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

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

@@ -1,9 +1,12 @@
+import { renderError } from "./response/errors.js";
 import { DEFAULT_TEST_ID } from "./constants.js";
 import { normalizeModelName } from "./model-utils.js";
 import { isAuthenticatedRequest, isRecognizedApiKeyHeader } from "./api-key-auth.js";
 import { getTestId, hasMintedRequestId, slugifyContext, slugifyTestId } from "./helpers.js";
 import { writeErrorResponse } from "./sse-writer.js";
+import { getEmbeddingRequest } from "./embedding-request.js";
 import { currentTurnHasToolResult, getLastMessageByRole, getTextContent } from "./router.js";
+import { captureUsage } from "./response/usage/recording.js";
 import { capturedRedactedData, collapseStreamingResponseWithResponsesTools, withoutResponsesToolFields } from "./stream-collapse.js";
 import { resolveUpstreamUrl } from "./url.js";
 import { applyConfiguredProviderAuth, applyProviderAuth } from "./provider-auth.js";
@@ -95,6 +98,7 @@ const STRIP_HEADERS = new Set([
 	"accept-encoding",
 	"x-test-id",
 	"x-aimock-strict",
+	"x-aimock-policy",
 	"x-aimock-context"
 ]);
 /**
@@ -293,19 +297,19 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : String(err);
 		defaults.logger.error(`Invalid upstream URL for provider "${providerKey}": ${upstreamUrl} (${msg})`);
-		writeErrorResponse(res, 502, JSON.stringify({ error: {
+		writeErrorResponse(res, 502, renderError("openai", "transport-failure", {
 			message: `Invalid upstream URL: ${upstreamUrl}`,
 			type: "proxy_error"
-		} }));
+		}).body);
 		return "relayed";
 	}
 	defaults.logger.warn(`NO FIXTURE MATCH — proxying to ${upstreamUrl}${pathname}`);
 	const forwardHeaders = prepareEgressHeaders(req, target, providerKey, record.providerKeys?.[lookupKey]);
 	if (!forwardHeaders) {
-		writeErrorResponse(res, 502, JSON.stringify({ error: {
+		writeErrorResponse(res, 502, renderError("openai", "transport-failure", {
 			message: "No configured provider credential",
 			type: "proxy_error"
-		} }));
+		}).body);
 		return "relayed";
 	}
 	const requestBody = rawBody ?? JSON.stringify(request);
@@ -347,10 +351,10 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 		defaults.logger.error(`Proxy request failed: ${msg}`);
 		if (!res.headersSent) {
 			res.writeHead(502, { "Content-Type": "application/json" });
-			res.end(JSON.stringify({ error: {
+			res.end(renderError("openai", "transport-failure", {
 				message: `Proxy to upstream failed: ${msg}`,
 				type: "proxy_error"
-			} }));
+			}).body);
 		} else res.destroy();
 		return "relayed";
 	}
@@ -360,10 +364,10 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 			const ceilingMiB = Math.round(PROXY_BUFFER_HARD_CEILING / (1024 * 1024));
 			defaults.logger.error(`Upstream response exceeded the ${ceilingMiB} MiB proxy hard ceiling (saw ${totalBytes} bytes) on a non-progressive body — cannot relay the full body and refusing to relay a truncated one; returning 502`);
 			res.writeHead(502, { "Content-Type": "application/json" });
-			res.end(JSON.stringify({ error: {
+			res.end(renderError("openai", "transport-failure", {
 				message: `Upstream response exceeds ${ceilingMiB}MiB proxy ceiling`,
 				type: "proxy_error"
-			} }));
+			}).body);
 			return "relayed";
 		}
 		defaults.logger.warn(`Upstream response exceeded ${capDetail} (saw ${totalBytes} bytes) — relayed to client, recording skipped`);
@@ -395,7 +399,14 @@ 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 collapsedUsage = captureUsage({
+			provider: providerKey,
+			contentType: ctString,
+			operation: request._endpointType,
+			family: "final",
+			stage: "final",
+			observation: collapsed.usage
+		});
 		const usageSpread = collapsedUsage ? { usage: collapsedUsage } : {};
 		if (collapsed.transcription) fixtureResponse = { transcription: collapsed.transcription };
 		else if (collapsed.audioB64) {
@@ -494,7 +505,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" || request._endpointType === "elevenlabs-voice-design" || request._endpointType === "elevenlabs-voice" || request._endpointType === "elevenlabs-voice-get" || request._endpointType === "elevenlabs-voice-delete") && parsedResponse !== null) {
+		if ((providerKey === "ollama" && new URL(pathname, "http://localhost").pathname === "/api/embed" || 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;
@@ -510,7 +521,11 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 				json: parsedResponse,
 				status: upstreamStatus
 			};
-		} else fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, defaults.logger, request);
+		} else fixtureResponse = buildFixtureResponse(parsedResponse, upstreamStatus, defaults.logger, request, {
+			provider: providerKey,
+			contentType: ctString,
+			operation: request._endpointType
+		});
 	}
 	if (clientDisconnected) {
 		if (!sawDone) {
@@ -530,8 +545,15 @@ async function proxyAndRecord(req, res, request, providerKey, pathname, fixtures
 	}
 	const matchRequest = defaults.requestTransform ? defaults.requestTransform(request) : request;
 	const metadata = buildFixtureMetadata(request);
+	const embeddingRequest = getEmbeddingRequest(request);
 	const fixture = {
-		match: buildFixtureMatch(matchRequest, defaults.record),
+		match: {
+			...buildFixtureMatch(matchRequest, defaults.record),
+			...embeddingRequest && {
+				embeddingRequest: structuredClone(embeddingRequest),
+				...matchRequest.model !== void 0 && { model: matchRequest.model }
+			}
+		},
 		response: fixtureResponse,
 		...recordedTimings && { recordedTimings },
 		...metadata && { metadata }
@@ -841,67 +863,10 @@ 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.
 */
-function buildFixtureResponse(parsed, status, logger, request) {
+function buildFixtureResponse(parsed, status, logger, request, captureContext = {}) {
 	if (parsed === null || parsed === void 0) return {
 		error: {
 			message: "Upstream returned non-JSON response",
@@ -955,16 +920,32 @@ function buildFixtureResponse(parsed, status, logger, request) {
 		return { images };
 	}
 	const isTranscriptionRequest = request?._endpointType === "transcription" || request?._endpointType === "translation";
-	if (typeof obj.text === "string" && (isTranscriptionRequest || obj.task === "transcribe" || obj.language !== void 0 && obj.duration !== void 0) && !("choices" in obj) && !("candidates" in obj) && !("object" in obj) && !("message" in obj) && !("outputs" in obj)) return { transcription: {
-		text: obj.text,
-		...obj.language ? { language: String(obj.language) } : {},
-		...Array.isArray(obj.languages) ? { languages: obj.languages.filter((language) => typeof language === "object" && language !== null && typeof language.code === "string").map((language) => ({ code: language.code })) } : {},
-		...obj.duration !== void 0 ? { duration: Number(obj.duration) } : {},
-		...obj.usage && typeof obj.usage === "object" ? { usage: obj.usage } : {},
-		...Array.isArray(obj.words) ? { words: obj.words } : {},
-		...Array.isArray(obj.segments) ? { segments: obj.segments } : {}
-	} };
+	if (typeof obj.text === "string" && (isTranscriptionRequest || obj.task === "transcribe" || obj.language !== void 0 && obj.duration !== void 0) && !("choices" in obj) && !("candidates" in obj) && !("object" in obj) && !("message" in obj) && !("outputs" in obj)) {
+		const transcriptionUsage = captureUsage({
+			...captureContext,
+			family: "transcription",
+			stage: "nonstream",
+			observation: obj
+		});
+		const transcriptionUsageSpread = transcriptionUsage ? { usage: transcriptionUsage } : {};
+		return { transcription: {
+			text: obj.text,
+			...obj.language ? { language: String(obj.language) } : {},
+			...Array.isArray(obj.languages) ? { languages: obj.languages.filter((language) => typeof language === "object" && language !== null && typeof language.code === "string").map((language) => ({ code: language.code })) } : {},
+			...obj.duration !== void 0 ? { duration: Number(obj.duration) } : {},
+			...transcriptionUsageSpread,
+			...Array.isArray(obj.words) ? { words: obj.words } : {},
+			...Array.isArray(obj.segments) ? { segments: obj.segments } : {}
+		} };
+	}
 	if (Array.isArray(obj.outputs) && obj.outputs.length > 0 && !("choices" in obj) && !("content" in obj) && !("candidates" in obj)) {
+		const capturedUsage = captureUsage({
+			...captureContext,
+			family: "interactions",
+			stage: "nonstream",
+			observation: obj
+		});
+		const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 		const outputs = obj.outputs;
 		const fnCallOutputs = outputs.filter((o) => o.type === "function_call");
 		const textOutputs = outputs.filter((o) => o.type === "text" && typeof o.text === "string");
@@ -978,13 +959,23 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				...o.id ? { id: String(o.id) } : {}
 			}));
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				toolCalls
 			};
-			return { toolCalls };
+			return {
+				...usageSpread,
+				toolCalls
+			};
 		}
-		if (hasContent) return { content: joinedText };
-		return { content: "" };
+		if (hasContent) return {
+			...usageSpread,
+			content: joinedText
+		};
+		return {
+			...usageSpread,
+			content: ""
+		};
 	}
 	if (typeof obj.id === "string" && typeof obj.status === "string" && (obj.status === "completed" || obj.status === "in_progress" || obj.status === "failed") && !("choices" in obj) && !("content" in obj) && !("candidates" in obj) && !("message" in obj) && !("data" in obj) && !("object" in obj) && !("outputs" in obj) && !("model" in obj) && !("response" in obj) && !("done" in obj) && !("usage" in obj) && !("error" in obj)) {
 		if (obj.status === "completed" && obj.url) return { video: {
@@ -1004,7 +995,12 @@ 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 openaiUsage = captureUsage({
+				...captureContext,
+				family: "openai",
+				stage: "nonstream",
+				observation: obj
+			});
 			const usageSpread = openaiUsage ? { usage: openaiUsage } : {};
 			if (hasToolCalls) {
 				const toolCalls = message.tool_calls.map((tc) => {
@@ -1040,6 +1036,13 @@ function buildFixtureResponse(parsed, status, logger, request) {
 		}
 	}
 	if (Array.isArray(obj.content) && obj.content.length > 0) {
+		const capturedUsage = captureUsage({
+			...captureContext,
+			family: "anthropic",
+			stage: "nonstream",
+			observation: obj
+		});
+		const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 		const blocks = obj.content;
 		const toolUseBlocks = blocks.filter((b) => b.type === "tool_use");
 		const textBlocks = blocks.filter((b) => b.type === "text" && typeof b.text === "string");
@@ -1065,6 +1068,7 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				...b.id ? { id: String(b.id) } : {}
 			}));
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				toolCalls,
 				...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
@@ -1072,6 +1076,7 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				...redactedThinkingSpread
 			};
 			return {
+				...usageSpread,
 				toolCalls,
 				...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
 				...reasoningSignatureSpread,
@@ -1079,12 +1084,14 @@ function buildFixtureResponse(parsed, status, logger, request) {
 			};
 		}
 		if (hasContent) return {
+			...usageSpread,
 			content: joinedText,
 			...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
 			...reasoningSignatureSpread,
 			...redactedThinkingSpread
 		};
 		if (thinkingBlocks.length > 0 || redactedBlocks.length > 0) return {
+			...usageSpread,
 			content: "",
 			...anthropicReasoning ? { reasoning: anthropicReasoning } : {},
 			...reasoningSignatureSpread,
@@ -1094,6 +1101,13 @@ function buildFixtureResponse(parsed, status, logger, request) {
 	if (Array.isArray(obj.candidates) && obj.candidates.length > 0) {
 		const content = obj.candidates[0].content;
 		if (content && Array.isArray(content.parts)) {
+			const capturedUsage = captureUsage({
+				...captureContext,
+				family: "gemini",
+				stage: "nonstream",
+				observation: obj
+			});
+			const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 			const parts = content.parts;
 			const audioParts = parts.filter((p) => {
 				const inline = p.inlineData;
@@ -1104,10 +1118,13 @@ function buildFixtureResponse(parsed, status, logger, request) {
 			});
 			if (audioParts.length > 0) {
 				const inlineData = audioParts[0].inlineData;
-				return { audio: {
-					b64Json: String(inlineData.data ?? ""),
-					contentType: typeof inlineData.mimeType === "string" && inlineData.mimeType.length > 0 ? inlineData.mimeType : "audio/mpeg"
-				} };
+				return {
+					...usageSpread,
+					audio: {
+						b64Json: String(inlineData.data ?? ""),
+						contentType: typeof inlineData.mimeType === "string" && inlineData.mimeType.length > 0 ? inlineData.mimeType : "audio/mpeg"
+					}
+				};
 			}
 			const fnCallParts = parts.filter((p) => p.functionCall);
 			const textParts = parts.filter((p) => typeof p.text === "string" && !p.thought);
@@ -1125,20 +1142,24 @@ function buildFixtureResponse(parsed, status, logger, request) {
 					};
 				});
 				if (hasContent) return {
+					...usageSpread,
 					content: joinedText,
 					toolCalls,
 					...geminiReasoning ? { reasoning: geminiReasoning } : {}
 				};
 				return {
+					...usageSpread,
 					toolCalls,
 					...geminiReasoning ? { reasoning: geminiReasoning } : {}
 				};
 			}
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				...geminiReasoning ? { reasoning: geminiReasoning } : {}
 			};
 			return {
+				...usageSpread,
 				content: "",
 				...geminiReasoning ? { reasoning: geminiReasoning } : {}
 			};
@@ -1147,6 +1168,13 @@ function buildFixtureResponse(parsed, status, logger, request) {
 	if (obj.output && typeof obj.output === "object") {
 		const msg = obj.output.message;
 		if (msg && Array.isArray(msg.content)) {
+			const capturedUsage = captureUsage({
+				...captureContext,
+				family: "bedrock-converse",
+				stage: "nonstream",
+				observation: obj
+			});
+			const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 			const blocks = msg.content;
 			const toolUseBlocks = blocks.filter((b) => b.toolUse);
 			const textBlocks = blocks.filter((b) => typeof b.text === "string");
@@ -1168,26 +1196,37 @@ function buildFixtureResponse(parsed, status, logger, request) {
 					};
 				});
 				if (hasContent) return {
+					...usageSpread,
 					content: joinedText,
 					toolCalls,
 					...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
 				};
 				return {
+					...usageSpread,
 					toolCalls,
 					...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
 				};
 			}
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
 			};
 			return {
+				...usageSpread,
 				content: "",
 				...bedrockReasoning ? { reasoning: bedrockReasoning } : {}
 			};
 		}
 	}
 	if (typeof obj.finish_reason === "string" && obj.message && typeof obj.message === "object" && Array.isArray(obj.message.content)) {
+		const capturedUsage = captureUsage({
+			...captureContext,
+			family: "cohere",
+			stage: "nonstream",
+			observation: obj
+		});
+		const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 		const msg = obj.message;
 		const contentBlocks = msg.content;
 		const joinedText = contentBlocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => String(b.text ?? "")).join("");
@@ -1201,10 +1240,14 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				...b.id ? { id: String(b.id) } : {}
 			}));
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				toolCalls
 			};
-			return { toolCalls };
+			return {
+				...usageSpread,
+				toolCalls
+			};
 		}
 		if (msgToolCalls.length > 0) {
 			const toolCalls = msgToolCalls.map((tc) => {
@@ -1216,15 +1259,32 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				};
 			});
 			if (hasContent) return {
+				...usageSpread,
 				content: joinedText,
 				toolCalls
 			};
-			return { toolCalls };
+			return {
+				...usageSpread,
+				toolCalls
+			};
 		}
-		if (hasContent) return { content: joinedText };
-		return { content: "" };
+		if (hasContent) return {
+			...usageSpread,
+			content: joinedText
+		};
+		return {
+			...usageSpread,
+			content: ""
+		};
 	}
 	if (obj.message && typeof obj.message === "object") {
+		const capturedUsage = captureUsage({
+			...captureContext,
+			family: "ollama",
+			stage: "nonstream",
+			observation: obj
+		});
+		const usageSpread = capturedUsage ? { usage: capturedUsage } : {};
 		const msg = obj.message;
 		const hasOllamaToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
 		const hasOllamaContent = typeof msg.content === "string" && msg.content.length > 0;
@@ -1237,18 +1297,39 @@ function buildFixtureResponse(parsed, status, logger, request) {
 				};
 			});
 			if (hasOllamaContent) return {
+				...usageSpread,
 				content: msg.content,
 				toolCalls
 			};
-			return { toolCalls };
+			return {
+				...usageSpread,
+				toolCalls
+			};
 		}
-		if (hasOllamaContent) return { content: msg.content };
+		if (hasOllamaContent) return {
+			...usageSpread,
+			content: msg.content
+		};
 		if (Array.isArray(msg.content) && msg.content.length > 0) {
 			const first = msg.content[0];
-			if (typeof first.text === "string") return { content: first.text };
+			if (typeof first.text === "string") return {
+				...usageSpread,
+				content: first.text
+			};
 		}
 	}
-	if (typeof obj.response === "string" && typeof obj.done === "boolean") return { content: obj.response };
+	if (typeof obj.response === "string" && typeof obj.done === "boolean") {
+		const capturedUsage = captureUsage({
+			...captureContext,
+			family: "ollama",
+			stage: "nonstream",
+			observation: obj
+		});
+		return {
+			...capturedUsage ? { usage: capturedUsage } : {},
+			content: obj.response
+		};
+	}
 	logger?.warn(`Could not detect response format from upstream (status=${status}) — saving as error fixture; top-level keys: [${Object.keys(obj).join(", ")}]`);
 	return {
 		error: {