@copilotkit/aimock 1.45.0 → 1.46.0

package/dist/stream-collapse.d.cts

@@ -56,15 +56,12 @@ interface CollapseResult {
   redactedThinking?: string[];
   webSearches?: string[];
   /**
-   * The provider-reported `usage` object from the stream's final usage frame,
-   * captured VERBATIM (#368). OpenAI-compatible streams (including OpenRouter)
-   * close with a `chat.completion.chunk` whose `choices` is empty and whose
-   * `usage` carries the real token counts — plus, on OpenRouter,
-   * `cost` / `cost_details` / `native_tokens_*`. Collapsing dropped that frame,
-   * so a recorded fixture could only ever replay estimated (`ceil(len/4)`) token
-   * counts and never a provider-reported cost. Last-usage-wins: a stream that
-   * emits several usage frames keeps the final one. Absent when the upstream
-   * stream carried no usage (e.g. `stream_options.include_usage` unset).
+   * Provider-reported usage captured with each wire's merge rule. OpenAI and
+   * OpenRouter preserve the last nonempty usage object, including cost fields.
+   * Anthropic Messages and Bedrock Claude invoke merge message_start usage
+   * with numeric message_delta updates; null keeps the earlier count. Cache
+   * TTL objects come from message_start. Other wire families omit usage.
+   * Absent when no usage was captured from the upstream stream.
    *
    * Kept as a loose record because the field set is provider-specific and
    * forward-extending; the recorder sanitizes it into the fixture
@@ -154,6 +151,8 @@ declare function collapseOpenAISSE(rawBody: string): CollapseResult;
 
 /**
  * Collapse Anthropic Claude Messages SSE stream into a single response.
+ * Captures start usage and numeric delta updates; null keeps the start value.
+ * Cache TTL objects are captured from message_start, alongside flat counts.
  *
  * Format:
  *   event: message_start\ndata: {...}\n\n
@@ -191,6 +190,8 @@ declare function collapseOllamaNDJSON(rawBody: string): CollapseResult;
 declare function collapseCohereSSE(rawBody: string): CollapseResult;
 /**
  * Collapse Bedrock binary Event Stream into a single response.
+ * Claude invoke events preserve usage with the Anthropic start/delta rules;
+ * Converse usage remains omitted.
  *
  * Each frame contains a JSON payload with event types like:
  *   contentBlockDelta, contentBlockStart, etc.

package/dist/stream-collapse.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-collapse.d.cts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA+eA;AAsjBA;AAkMA;AAyJA;AAmIA;AA6RA;;;;;AAyTA;AA2LA;;;AAGiB,cA3uEJ,0BA2uEI,EAAA,MAAA;;AAEd,iBAluEa,8BAAA,CAkuEb,KAAA,EAAA,MAAA,GAAA,SAAA,CAAA,EAAA,IAAA;AAAc,UAlrEA,cAAA,CAkrEA;;;;gBA9qED;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCF;;;;;cAKI;;;;;;oBAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoCT;;;;;;;oBAOS;;;;;;;;;;;;;;;;;;;;;;iBAwSJ,iBAAA,mBAAoC;;;;;;;;;;;;;iBAsjBpC,oBAAA,mBAAuC;;;;;;;iBAkMvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAyJpC,oBAAA,mBAAuC;;;;;;;iBAmIvC,iBAAA,mBAAoC;;;;;;;iBA6RpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBAyT7C,6BAAA,mBAAgD;;;;;;;;;iBA2LhD,yBAAA,mCAED,kCACE,iBACN,SACR"}
+{"version":3,"file":"stream-collapse.d.cts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA6eA;AA0jBA;AA+MA;AAuKA;AAgJA;AA4SA;;;;;AAsUA;AAwMA;;;AAGiB,cA7zEJ,0BA6zEI,EAAA,MAAA;;AAEd,iBApzEa,8BAAA,CAozEb,KAAA,EAAA,MAAA,GAAA,SAAA,CAAA,EAAA,IAAA;AAAc,UApwEA,cAAA,CAowEA;;;;gBAhwED;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCF;;;;;cAKI;;;;;;oBAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoCT;;;;;;;oBAOS;;;;;;;;;;;;;;;;;;;;;;iBAwSJ,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBA0jBpC,oBAAA,mBAAuC;;;;;;;iBA+MvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAuKpC,oBAAA,mBAAuC;;;;;;;iBAgJvC,iBAAA,mBAAoC;;;;;;;;;iBA4SpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBAsU7C,6BAAA,mBAAgD;;;;;;;;;iBAwMhD,yBAAA,mCAED,kCACE,iBACN,SACR"}

package/dist/stream-collapse.d.ts

@@ -56,15 +56,12 @@ interface CollapseResult {
   redactedThinking?: string[];
   webSearches?: string[];
   /**
-   * The provider-reported `usage` object from the stream's final usage frame,
-   * captured VERBATIM (#368). OpenAI-compatible streams (including OpenRouter)
-   * close with a `chat.completion.chunk` whose `choices` is empty and whose
-   * `usage` carries the real token counts — plus, on OpenRouter,
-   * `cost` / `cost_details` / `native_tokens_*`. Collapsing dropped that frame,
-   * so a recorded fixture could only ever replay estimated (`ceil(len/4)`) token
-   * counts and never a provider-reported cost. Last-usage-wins: a stream that
-   * emits several usage frames keeps the final one. Absent when the upstream
-   * stream carried no usage (e.g. `stream_options.include_usage` unset).
+   * Provider-reported usage captured with each wire's merge rule. OpenAI and
+   * OpenRouter preserve the last nonempty usage object, including cost fields.
+   * Anthropic Messages and Bedrock Claude invoke merge message_start usage
+   * with numeric message_delta updates; null keeps the earlier count. Cache
+   * TTL objects come from message_start. Other wire families omit usage.
+   * Absent when no usage was captured from the upstream stream.
    *
    * Kept as a loose record because the field set is provider-specific and
    * forward-extending; the recorder sanitizes it into the fixture
@@ -154,6 +151,8 @@ declare function collapseOpenAISSE(rawBody: string): CollapseResult;
 
 /**
  * Collapse Anthropic Claude Messages SSE stream into a single response.
+ * Captures start usage and numeric delta updates; null keeps the start value.
+ * Cache TTL objects are captured from message_start, alongside flat counts.
  *
  * Format:
  *   event: message_start\ndata: {...}\n\n
@@ -191,6 +190,8 @@ declare function collapseOllamaNDJSON(rawBody: string): CollapseResult;
 declare function collapseCohereSSE(rawBody: string): CollapseResult;
 /**
  * Collapse Bedrock binary Event Stream into a single response.
+ * Claude invoke events preserve usage with the Anthropic start/delta rules;
+ * Converse usage remains omitted.
  *
  * Each frame contains a JSON payload with event types like:
  *   contentBlockDelta, contentBlockStart, etc.

package/dist/stream-collapse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-collapse.d.ts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA+eA;AAsjBA;AAkMA;AAyJA;AAmIA;AA6RA;;;;;AAyTA;AA2LA;;;AAGiB,cA3uEJ,0BA2uEI,EAAA,MAAA;;AAEd,iBAluEa,8BAAA,CAkuEb,KAAA,EAAA,MAAA,GAAA,SAAA,CAAA,EAAA,IAAA;AAAc,UAlrEA,cAAA,CAkrEA;;;;gBA9qED;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCF;;;;;cAKI;;;;;;oBAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoCT;;;;;;;oBAOS;;;;;;;;;;;;;;;;;;;;;;iBAwSJ,iBAAA,mBAAoC;;;;;;;;;;;;;iBAsjBpC,oBAAA,mBAAuC;;;;;;;iBAkMvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAyJpC,oBAAA,mBAAuC;;;;;;;iBAmIvC,iBAAA,mBAAoC;;;;;;;iBA6RpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBAyT7C,6BAAA,mBAAgD;;;;;;;;;iBA2LhD,yBAAA,mCAED,kCACE,iBACN,SACR"}
+{"version":3,"file":"stream-collapse.d.ts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA6eA;AA0jBA;AA+MA;AAuKA;AAgJA;AA4SA;;;;;AAsUA;AAwMA;;;AAGiB,cA7zEJ,0BA6zEI,EAAA,MAAA;;AAEd,iBApzEa,8BAAA,CAozEb,KAAA,EAAA,MAAA,GAAA,SAAA,CAAA,EAAA,IAAA;AAAc,UApwEA,cAAA,CAowEA;;;;gBAhwED;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCF;;;;;cAKI;;;;;;oBAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoCT;;;;;;;oBAOS;;;;;;;;;;;;;;;;;;;;;;iBAwSJ,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBA0jBpC,oBAAA,mBAAuC;;;;;;;iBA+MvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAuKpC,oBAAA,mBAAuC;;;;;;;iBAgJvC,iBAAA,mBAAoC;;;;;;;;;iBA4SpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBAsU7C,6BAAA,mBAAgD;;;;;;;;;iBAwMhD,yBAAA,mCAED,kCACE,iBACN,SACR"}

package/dist/stream-collapse.js

@@ -1,3 +1,4 @@
+import { captureUsage } from "./response/usage/recording.js";
 import { isHarmonyContent, parseHarmonyContent } from "./harmony.js";
 import { crc32 } from "node:zlib";
 
@@ -360,7 +361,15 @@ function collapseOpenAISSEWithResponsesTools(rawBody) {
 			transcript = parsed.text;
 			transcriptSeen = true;
 			if (Array.isArray(parsed.languages)) transcriptLanguages = parsed.languages.filter((language) => typeof language === "object" && language !== null && typeof language.code === "string").map((language) => ({ code: language.code }));
-			if (parsed.usage && typeof parsed.usage === "object" && !Array.isArray(parsed.usage) && Object.keys(parsed.usage).length > 0) transcriptUsage = parsed.usage;
+			transcriptUsage = captureUsage({
+				provider: "openai",
+				contentType: "text/event-stream",
+				operation: "transcription",
+				family: "transcription",
+				stage: "stream",
+				previous: transcriptUsage,
+				observation: parsed
+			});
 			continue;
 		}
 		if (parsed.type === "response.reasoning_summary_text.delta" && typeof parsed.delta === "string") {
@@ -547,7 +556,15 @@ function collapseOpenAISSEWithResponsesTools(rawBody) {
 			continue;
 		}
 		if (typeof parsed.type === "string" && parsed.type.startsWith("response.")) continue;
-		if (parsed.usage && typeof parsed.usage === "object" && !Array.isArray(parsed.usage) && Object.keys(parsed.usage).length > 0) usage = parsed.usage;
+		usage = captureUsage({
+			provider: "openai",
+			contentType: "text/event-stream",
+			operation: "chat",
+			family: "openai",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		const choices = parsed.choices;
 		if (!choices || choices.length === 0) continue;
 		const delta = choices[0].delta;
@@ -663,6 +680,8 @@ function collapseOpenAISSEWithResponsesTools(rawBody) {
 }
 /**
 * Collapse Anthropic Claude Messages SSE stream into a single response.
+* Captures start usage and numeric delta updates; null keeps the start value.
+* Cache TTL objects are captured from message_start, alongside flat counts.
 *
 * Format:
 *   event: message_start\ndata: {...}\n\n
@@ -671,6 +690,7 @@ function collapseOpenAISSEWithResponsesTools(rawBody) {
 function collapseAnthropicSSE(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const blocks = splitSSEEvents(guardCollapseBody(rawBody));
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let reasoningSignature;
@@ -696,6 +716,15 @@ function collapseAnthropicSSE(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(payload, 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "anthropic",
+			contentType: "text/event-stream",
+			operation: "chat",
+			family: "anthropic",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		if (eventType === "content_block_start") {
 			const contentBlock = parsed.content_block;
 			const redactedData = capturedRedactedData(contentBlock);
@@ -753,6 +782,7 @@ function collapseAnthropicSSE(rawBody) {
 			...tc.id ? { id: tc.id } : {}
 		}));
 		return {
+			...usage ? { usage } : {},
 			...orderedBlocks ? { blocks: orderedBlocks } : {},
 			...content ? { content } : {},
 			toolCalls: orderedBlocks ? orderedToolCalls : indexSortedToolCalls,
@@ -765,6 +795,7 @@ function collapseAnthropicSSE(rawBody) {
 		};
 	}
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...reasoningSignature ? { reasoningSignature } : {},
@@ -783,6 +814,7 @@ function collapseAnthropicSSE(rawBody) {
 function collapseGeminiSSE(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const lines = splitSSEEvents(guardCollapseBody(rawBody));
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -803,6 +835,15 @@ function collapseGeminiSSE(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(payload, 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "gemini",
+			contentType: "text/event-stream",
+			operation: "chat",
+			family: "gemini",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		const candidates = parsed.candidates;
 		if (!candidates || candidates.length === 0) continue;
 		const candidateContent = candidates[0].content;
@@ -838,6 +879,7 @@ function collapseGeminiSSE(rawBody) {
 		arguments: normalizeToolArguments(tc.arguments)
 	}));
 	if (audioB64) return {
+		...usage ? { usage } : {},
 		audioB64,
 		audioMimeType,
 		...content ? { content } : {},
@@ -850,6 +892,7 @@ function collapseGeminiSSE(rawBody) {
 	if (toolCalls.length > 0) {
 		const blocks = buildOrderedBlocks(orderAtoms);
 		return {
+			...usage ? { usage } : {},
 			...blocks ? { blocks } : {},
 			...content ? { content } : {},
 			toolCalls: normalizedToolCalls,
@@ -860,6 +903,7 @@ function collapseGeminiSSE(rawBody) {
 		};
 	}
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
@@ -884,6 +928,7 @@ function collapseGeminiSSE(rawBody) {
 function collapseOllamaNDJSON(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const lines = guardCollapseBody(rawBody).split("\n").filter((l) => l.trim().length > 0);
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -901,6 +946,15 @@ function collapseOllamaNDJSON(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(line.trim(), 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "ollama",
+			contentType: "application/x-ndjson",
+			operation: "chat",
+			family: "ollama",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		const message = parsed.message;
 		if (message) {
 			if (typeof message.content === "string") {
@@ -950,6 +1004,7 @@ function collapseOllamaNDJSON(rawBody) {
 			arguments: normalizeToolArguments(tc.arguments)
 		}));
 		return {
+			...usage ? { usage } : {},
 			...blocks ? { blocks } : {},
 			...content ? { content } : {},
 			toolCalls: normalizedToolCalls,
@@ -962,6 +1017,7 @@ function collapseOllamaNDJSON(rawBody) {
 		};
 	}
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
@@ -980,6 +1036,7 @@ function collapseOllamaNDJSON(rawBody) {
 function collapseCohereSSE(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const blocks = splitSSEEvents(guardCollapseBody(rawBody));
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -1003,6 +1060,15 @@ function collapseCohereSSE(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(payload, 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "cohere",
+			contentType: "text/event-stream",
+			operation: "chat",
+			family: "cohere",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		if (eventType === "content-delta") {
 			const contentObj = (parsed.delta?.message)?.content;
 			if (contentObj && contentObj.type === "thinking" && typeof contentObj.thinking === "string") reasoning += contentObj.thinking;
@@ -1063,6 +1129,7 @@ function collapseCohereSSE(rawBody) {
 			...tc.id ? { id: tc.id } : {}
 		}));
 		return {
+			...usage ? { usage } : {},
 			...orderedBlocks ? { blocks: orderedBlocks } : {},
 			...content ? { content } : {},
 			toolCalls: orderedBlocks ? orderedToolCalls : indexSortedToolCalls,
@@ -1073,6 +1140,7 @@ function collapseCohereSSE(rawBody) {
 		};
 	}
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
@@ -1167,6 +1235,8 @@ function decodeEventStreamFrames(buf) {
 }
 /**
 * Collapse Bedrock binary Event Stream into a single response.
+* Claude invoke events preserve usage with the Anthropic start/delta rules;
+* Converse usage remains omitted.
 *
 * Each frame contains a JSON payload with event types like:
 *   contentBlockDelta, contentBlockStart, etc.
@@ -1176,6 +1246,7 @@ function collapseBedrockEventStream(rawBody) {
 	const inputTruncated = rawBody.byteLength > limit;
 	const { frames, truncated: frameTruncated } = decodeEventStreamFrames(inputTruncated ? rawBody.subarray(0, limit) : rawBody);
 	const truncated = frameTruncated || inputTruncated;
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let reasoningSignature;
@@ -1204,6 +1275,15 @@ function collapseBedrockEventStream(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(frameStr, 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "bedrock",
+			contentType: "application/vnd.amazon.eventstream",
+			operation: "chat",
+			family: typeof parsed.type === "string" ? "bedrock-invoke" : "bedrock-converse",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		if (parsed.type === "content_block_delta") {
 			const delta = parsed.delta;
 			if (delta?.type === "text_delta" && typeof delta.text === "string") {
@@ -1311,6 +1391,7 @@ function collapseBedrockEventStream(rawBody) {
 			...tc.id ? { id: tc.id } : {}
 		}));
 		return {
+			...usage ? { usage } : {},
 			...orderedBlocks ? { blocks: orderedBlocks } : {},
 			...content ? { content } : {},
 			toolCalls: orderedBlocks ? orderedToolCalls : indexSortedToolCalls,
@@ -1323,6 +1404,7 @@ function collapseBedrockEventStream(rawBody) {
 		};
 	}
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...reasoningSignature ? { reasoningSignature } : {},
@@ -1349,6 +1431,7 @@ function collapseBedrockEventStream(rawBody) {
 function collapseGeminiInteractionsSSE(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const lines = splitSSEEvents(guardCollapseBody(rawBody));
+	let usage;
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -1368,6 +1451,15 @@ function collapseGeminiInteractionsSSE(rawBody) {
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(payload, 200)}`;
 			continue;
 		}
+		usage = captureUsage({
+			provider: "gemini-interactions",
+			contentType: "text/event-stream",
+			operation: "chat",
+			family: "interactions",
+			stage: "stream",
+			previous: usage,
+			observation: parsed
+		});
 		const eventType = parsed.event_type;
 		if (!eventType) continue;
 		const index = typeof parsed.index === "number" ? parsed.index : void 0;
@@ -1425,6 +1517,7 @@ function collapseGeminiInteractionsSSE(rawBody) {
 		});
 	}
 	if (toolCalls.length > 0) return {
+		...usage ? { usage } : {},
 		...content ? { content } : {},
 		toolCalls,
 		...reasoning ? { reasoning } : {},
@@ -1433,6 +1526,7 @@ function collapseGeminiInteractionsSSE(rawBody) {
 		...inputTruncated ? { truncated: true } : {}
 	};
 	return {
+		...usage ? { usage } : {},
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
@@ -1458,24 +1552,37 @@ function collapseStreamingResponse(contentType, providerKey, body, logger) {
 */
 function collapseStreamingResponseWithResponsesTools(contentType, providerKey, body, logger) {
 	const ct = contentType.toLowerCase();
-	if (ct.includes("application/vnd.amazon.eventstream")) return collapseBedrockEventStream(typeof body === "string" ? Buffer.from(body, "binary") : body);
-	if (ct.includes("application/x-ndjson")) return collapseOllamaNDJSON(typeof body === "string" ? body : body.toString("utf8"));
+	const complete = (result) => {
+		const usage = captureUsage({
+			provider: providerKey,
+			contentType,
+			family: "stream-dispatch",
+			stage: "collapsed",
+			observation: result
+		});
+		return usage ? {
+			...result,
+			usage
+		} : result;
+	};
+	if (ct.includes("application/vnd.amazon.eventstream")) return complete(collapseBedrockEventStream(typeof body === "string" ? Buffer.from(body, "binary") : body));
+	if (ct.includes("application/x-ndjson")) return complete(collapseOllamaNDJSON(typeof body === "string" ? body : body.toString("utf8")));
 	if (ct.includes("text/event-stream")) {
 		const str = typeof body === "string" ? body : body.toString("utf8");
 		switch (providerKey) {
 			case "openai":
 			case "azure":
 			case "openrouter":
-			case "byteplus": return collapseOpenAISSEWithResponsesTools(str);
-			case "anthropic": return collapseAnthropicSSE(str);
+			case "byteplus": return complete(collapseOpenAISSEWithResponsesTools(str));
+			case "anthropic": return complete(collapseAnthropicSSE(str));
 			case "gemini":
-			case "vertexai": return collapseGeminiSSE(str);
-			case "gemini-interactions": return collapseGeminiInteractionsSSE(str);
-			case "cohere": return collapseCohereSSE(str);
-			case "bedrock": return collapseAnthropicSSE(str);
+			case "vertexai": return complete(collapseGeminiSSE(str));
+			case "gemini-interactions": return complete(collapseGeminiInteractionsSSE(str));
+			case "cohere": return complete(collapseCohereSSE(str));
+			case "bedrock": return complete(collapseAnthropicSSE(str));
 			default:
 				logger?.warn(`[stream-collapse] unknown SSE provider "${providerKey}", falling back to OpenAI SSE format`);
-				return collapseOpenAISSEWithResponsesTools(str);
+				return complete(collapseOpenAISSEWithResponsesTools(str));
 		}
 	}
 	return null;