@copilotkit/aimock 1.37.0 → 1.37.2

package/dist/stream-collapse.d.ts

@@ -3,6 +3,29 @@ import { FixtureBlock, RecordProviderKey, ToolCall } from "./types.js";
 
 //#region src/stream-collapse.d.ts
 
+/**
+ * Hard ceiling (UTF-16 code units) for any SINGLE string a collapser
+ * accumulates across deltas (`content`, `reasoning`, a tool call's
+ * `arguments`, `audioB64`, `argsStr`, and the coalesced text of `orderAtoms`).
+ *
+ * V8's maximum string length on 64-bit is 2^29 - 1 (~536.8M UTF-16 code
+ * units); appending past it throws `RangeError: Invalid string length`. The
+ * proxy path bounds the raw BYTE buffer under `PROXY_BUFFER_HARD_CEILING`
+ * (256 MiB) before collapse, but the collapser is ALSO reachable directly
+ * (exported from index.ts) and — even on the proxy path — a single accumulator
+ * can approach the byte budget in code units, so it needs its own guard rather
+ * than relying on the byte cap alone. 256Mi code units is comfortably below
+ * V8's limit while leaving huge headroom for any real completion (whose
+ * accumulated content can never exceed the total streamed body).
+ *
+ * When an append would cross the ceiling the accumulator keeps the ceiling's
+ * worth of characters, drops the overflow, and marks itself truncated — never
+ * throwing — mirroring the proxy buffer's "bound then mark truncated, never
+ * fail the client" discipline.
+ */
+declare const MAX_COLLAPSE_STRING_LENGTH: number;
+/** @internal test-only — see {@link collapseStringLimitOverride}. */
+declare function setCollapseStringLimitForTests(value: number | undefined): void;
 interface CollapseResult {
   content?: string;
   reasoning?: string;
@@ -76,7 +99,7 @@ interface CollapseResult {
  *   data: {"id":"chatcmpl-123","choices":[{"delta":{"content":"Hello"}}]}\n\n
  *   data: [DONE]\n\n
  */
-declare function collapseOpenAISSE(body: string): CollapseResult;
+declare function collapseOpenAISSE(rawBody: string): CollapseResult;
 /**
  * Collapse Anthropic Claude Messages SSE stream into a single response.
  *
@@ -84,14 +107,14 @@ declare function collapseOpenAISSE(body: string): CollapseResult;
  *   event: message_start\ndata: {...}\n\n
  *   event: content_block_delta\ndata: {"delta":{"type":"text_delta","text":"Hello"}}\n\n
  */
-declare function collapseAnthropicSSE(body: string): CollapseResult;
+declare function collapseAnthropicSSE(rawBody: string): CollapseResult;
 /**
  * Collapse Gemini SSE stream into a single response.
  *
  * Format (data-only, no event prefix, no [DONE]):
  *   data: {"candidates":[{"content":{"parts":[{"text":"Hello"}]}}]}\n\n
  */
-declare function collapseGeminiSSE(body: string): CollapseResult;
+declare function collapseGeminiSSE(rawBody: string): CollapseResult;
 /**
  * Collapse Ollama NDJSON stream into a single response.
  *
@@ -106,21 +129,21 @@ declare function collapseGeminiSSE(body: string): CollapseResult;
  * content is run through the same fail-safe {@link parseHarmonyContent} gate to
  * capture structured tool calls / reasoning instead of leaking raw tokens.
  */
-declare function collapseOllamaNDJSON(body: string): CollapseResult;
+declare function collapseOllamaNDJSON(rawBody: string): CollapseResult;
 /**
  * Collapse Cohere SSE stream into a single response.
  *
  * Format:
  *   event: content-delta\ndata: {"type":"content-delta","delta":{"message":{"content":{"text":"Hello"}}}}\n\n
  */
-declare function collapseCohereSSE(body: string): CollapseResult;
+declare function collapseCohereSSE(rawBody: string): CollapseResult;
 /**
  * Collapse Bedrock binary Event Stream into a single response.
  *
  * Each frame contains a JSON payload with event types like:
  *   contentBlockDelta, contentBlockStart, etc.
  */
-declare function collapseBedrockEventStream(body: Buffer): CollapseResult;
+declare function collapseBedrockEventStream(rawBody: Buffer): CollapseResult;
 /**
  * Collapse Gemini Interactions SSE stream into a single response.
  *
@@ -135,7 +158,7 @@ declare function collapseBedrockEventStream(body: Buffer): CollapseResult;
  * delta) are still accepted for backward compatibility with previously
  * recorded fixtures.
  */
-declare function collapseGeminiInteractionsSSE(body: string): CollapseResult;
+declare function collapseGeminiInteractionsSSE(rawBody: string): CollapseResult;
 /**
  * Collapse a streaming response body into a non-streaming fixture response.
  * Returns null if the content type is not a known streaming format.
@@ -144,5 +167,5 @@ declare function collapseGeminiInteractionsSSE(body: string): CollapseResult;
 declare function collapseStreamingResponse(contentType: string, providerKey: RecordProviderKey, body: string | Buffer, logger?: Logger): CollapseResult | null;
 //# sourceMappingURL=stream-collapse.d.ts.map
 //#endregion
-export { CollapseResult, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse };
+export { CollapseResult, MAX_COLLAPSE_STRING_LENGTH, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse, setCollapseStringLimitForTests };
 //# sourceMappingURL=stream-collapse.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stream-collapse.d.ts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;AAkgBgB,UAhfC,cAAA,CAgfmB;EA8LpB,OAAA,CAAA,EAAA,MAAA;EAoJA,SAAA,CAAA,EAAA,MAAA;EA+HA;AAqRhB;;;;;AAoPA;AAoLA;;;;oBAIW,CAAA,EAAA,MAAA;;;;;;;;cA5mDG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCH;;;;;;;;;;;;;;;;;;;iBA+MK,iBAAA,gBAAiC;;;;;;;;iBA2OjC,oBAAA,gBAAoC;;;;;;;iBA8LpC,iBAAA,gBAAiC;;;;;;;;;;;;;;;iBAoJjC,oBAAA,gBAAoC;;;;;;;iBA+HpC,iBAAA,gBAAiC;;;;;;;iBAqRjC,0BAAA,OAAiC,SAAS;;;;;;;;;;;;;;;iBAoP1C,6BAAA,gBAA6C;;;;;;iBAoL7C,yBAAA,mCAED,kCACE,iBACN,SACR"}
+{"version":3,"file":"stream-collapse.d.ts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;AAsWA;AA+OA;AAkMA;AAyJA;AAmIA;AAyRA;;;;;AA8PA;AAwLA;;;;;;;;cA5tDa;;iBAWG,8BAAA;UAgDC,cAAA;;;;;;;;;;;;;;;;;;;;;;cAsBH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCH;;;;;;;;;;;;;;;;;;;iBA+MK,iBAAA,mBAAoC;;;;;;;;iBA+OpC,oBAAA,mBAAuC;;;;;;;iBAkMvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAyJpC,oBAAA,mBAAuC;;;;;;;iBAmIvC,iBAAA,mBAAoC;;;;;;;iBAyRpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBA8P7C,6BAAA,mBAAgD;;;;;;iBAwLhD,yBAAA,mCAED,kCACE,iBACN,SACR"}

package/dist/stream-collapse.js

@@ -11,6 +11,75 @@ import { crc32 } from "node:zlib";
 * text followed by tool calls.
 */
 /**
+* Hard ceiling (UTF-16 code units) for any SINGLE string a collapser
+* accumulates across deltas (`content`, `reasoning`, a tool call's
+* `arguments`, `audioB64`, `argsStr`, and the coalesced text of `orderAtoms`).
+*
+* V8's maximum string length on 64-bit is 2^29 - 1 (~536.8M UTF-16 code
+* units); appending past it throws `RangeError: Invalid string length`. The
+* proxy path bounds the raw BYTE buffer under `PROXY_BUFFER_HARD_CEILING`
+* (256 MiB) before collapse, but the collapser is ALSO reachable directly
+* (exported from index.ts) and — even on the proxy path — a single accumulator
+* can approach the byte budget in code units, so it needs its own guard rather
+* than relying on the byte cap alone. 256Mi code units is comfortably below
+* V8's limit while leaving huge headroom for any real completion (whose
+* accumulated content can never exceed the total streamed body).
+*
+* When an append would cross the ceiling the accumulator keeps the ceiling's
+* worth of characters, drops the overflow, and marks itself truncated — never
+* throwing — mirroring the proxy buffer's "bound then mark truncated, never
+* fail the client" discipline.
+*/
+const MAX_COLLAPSE_STRING_LENGTH = 256 * 1024 * 1024;
+/**
+* Test-only override of {@link MAX_COLLAPSE_STRING_LENGTH}. Lets the cap suite
+* exercise the truncation path with a tiny budget instead of building a
+* multi-hundred-MB string. `undefined` (the default) uses the real ceiling.
+* NEVER set from production code.
+*/
+let collapseStringLimitOverride;
+/** @internal test-only — see {@link collapseStringLimitOverride}. */
+function setCollapseStringLimitForTests(value) {
+	collapseStringLimitOverride = value;
+}
+/** Effective accumulated-string ceiling, honoring any active test-only override. */
+function effectiveCollapseStringLimit() {
+	return collapseStringLimitOverride ?? MAX_COLLAPSE_STRING_LENGTH;
+}
+/**
+* Guard a raw collapse-input body against V8's max string length BEFORE any
+* per-delta accumulation begins. Every collapser accumulates `content` /
+* `reasoning` / a tool call's `arguments` / `audioB64` / `argsStr` (and the
+* coalesced text of `orderAtoms`) from fragments of `body`; the sum of any one
+* of those accumulators can never exceed the total input length, so bounding
+* the INPUT under the ceiling bounds EVERY accumulator at once — no per-`+=`
+* site can then build a string past the limit and throw
+* `RangeError: Invalid string length` (the ~1/sec prod crash).
+*
+* Returns the body UNCHANGED when it is within the ceiling. When it exceeds the
+* ceiling this returns a hard-truncated prefix (never throwing) — the collapse
+* result the caller builds from it is marked incomplete via `truncated: true`
+* (see {@link isCollapseInputTruncated}). This mirrors the proxy buffer's
+* "bound then mark truncated, never fail the client" discipline: on the proxy
+* path a body this large has already tripped the byte cap and skipped recording,
+* so this is a defense-in-depth backstop that also covers the direct (exported)
+* collapse callers where no byte cap ran.
+*/
+function guardCollapseBody(body) {
+	const limit = effectiveCollapseStringLimit();
+	if (body.length <= limit) return body;
+	return body.slice(0, limit);
+}
+/**
+* True when a body exceeded the accumulated-string ceiling and had to be
+* truncated by {@link guardCollapseBody}. Collapsers stamp `truncated: true` on
+* their result in this case so the recorder skips journaling a partial fixture,
+* exactly like a transport-truncated stream.
+*/
+function isCollapseInputTruncated(body) {
+	return body.length > effectiveCollapseStringLimit();
+}
+/**
 * Normalize a tool call's accumulated `arguments` into valid JSON exactly like
 * the flat-`toolCalls` recorder path: an empty / whitespace-only / missing
 * value becomes `"{}"`, never `""`. Mirrors `recorder.ts` `toToolCallArguments`
@@ -165,8 +234,9 @@ function extractSSEData(lines) {
 *   data: {"id":"chatcmpl-123","choices":[{"delta":{"content":"Hello"}}]}\n\n
 *   data: [DONE]\n\n
 */
-function collapseOpenAISSE(body) {
-	const lines = splitSSEEvents(body);
+function collapseOpenAISSE(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const lines = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
 	let reasoning = "";
 	const webSearchQueries = [];
@@ -287,7 +357,8 @@ function collapseOpenAISSE(body) {
 			...droppedChunks > 0 ? { droppedChunks } : {},
 			...firstDroppedSample ? { firstDroppedSample } : {},
 			...harmonyUnparsed ? { harmonyUnparsed: true } : {},
-			...harmonyNote ? { harmonyNote } : {}
+			...harmonyNote ? { harmonyNote } : {},
+			...inputTruncated ? { truncated: true } : {}
 		};
 	}
 	return {
@@ -297,7 +368,8 @@ function collapseOpenAISSE(body) {
 		...droppedChunks > 0 ? { droppedChunks } : {},
 		...firstDroppedSample ? { firstDroppedSample } : {},
 		...harmonyUnparsed ? { harmonyUnparsed: true } : {},
-		...harmonyNote ? { harmonyNote } : {}
+		...harmonyNote ? { harmonyNote } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -307,8 +379,9 @@ function collapseOpenAISSE(body) {
 *   event: message_start\ndata: {...}\n\n
 *   event: content_block_delta\ndata: {"delta":{"type":"text_delta","text":"Hello"}}\n\n
 */
-function collapseAnthropicSSE(body) {
-	const blocks = splitSSEEvents(body);
+function collapseAnthropicSSE(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const blocks = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
 	let reasoning = "";
 	let reasoningSignature;
@@ -398,7 +471,8 @@ function collapseAnthropicSSE(body) {
 			...reasoningSignature ? { reasoningSignature } : {},
 			...redactedThinking.length > 0 ? { redactedThinking } : {},
 			...droppedChunks > 0 ? { droppedChunks } : {},
-			...firstDroppedSample ? { firstDroppedSample } : {}
+			...firstDroppedSample ? { firstDroppedSample } : {},
+			...inputTruncated ? { truncated: true } : {}
 		};
 	}
 	return {
@@ -407,7 +481,8 @@ function collapseAnthropicSSE(body) {
 		...reasoningSignature ? { reasoningSignature } : {},
 		...redactedThinking.length > 0 ? { redactedThinking } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -416,8 +491,9 @@ function collapseAnthropicSSE(body) {
 * Format (data-only, no event prefix, no [DONE]):
 *   data: {"candidates":[{"content":{"parts":[{"text":"Hello"}]}}]}\n\n
 */
-function collapseGeminiSSE(body) {
-	const lines = splitSSEEvents(body);
+function collapseGeminiSSE(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const lines = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -479,7 +555,8 @@ function collapseGeminiSSE(body) {
 		...reasoning ? { reasoning } : {},
 		...normalizedToolCalls.length > 0 ? { toolCalls: normalizedToolCalls } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 	if (toolCalls.length > 0) {
 		const blocks = buildOrderedBlocks(orderAtoms);
@@ -489,14 +566,16 @@ function collapseGeminiSSE(body) {
 			toolCalls: normalizedToolCalls,
 			...reasoning ? { reasoning } : {},
 			...droppedChunks > 0 ? { droppedChunks } : {},
-			...firstDroppedSample ? { firstDroppedSample } : {}
+			...firstDroppedSample ? { firstDroppedSample } : {},
+			...inputTruncated ? { truncated: true } : {}
 		};
 	}
 	return {
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -513,8 +592,9 @@ function collapseGeminiSSE(body) {
 * content is run through the same fail-safe {@link parseHarmonyContent} gate to
 * capture structured tool calls / reasoning instead of leaking raw tokens.
 */
-function collapseOllamaNDJSON(body) {
-	const lines = body.split("\n").filter((l) => l.trim().length > 0);
+function collapseOllamaNDJSON(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const lines = guardCollapseBody(rawBody).split("\n").filter((l) => l.trim().length > 0);
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -588,7 +668,8 @@ function collapseOllamaNDJSON(body) {
 			...droppedChunks > 0 ? { droppedChunks } : {},
 			...firstDroppedSample ? { firstDroppedSample } : {},
 			...harmonyUnparsed ? { harmonyUnparsed: true } : {},
-			...harmonyNote ? { harmonyNote } : {}
+			...harmonyNote ? { harmonyNote } : {},
+			...inputTruncated ? { truncated: true } : {}
 		};
 	}
 	return {
@@ -597,7 +678,8 @@ function collapseOllamaNDJSON(body) {
 		...droppedChunks > 0 ? { droppedChunks } : {},
 		...firstDroppedSample ? { firstDroppedSample } : {},
 		...harmonyUnparsed ? { harmonyUnparsed: true } : {},
-		...harmonyNote ? { harmonyNote } : {}
+		...harmonyNote ? { harmonyNote } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -606,8 +688,9 @@ function collapseOllamaNDJSON(body) {
 * Format:
 *   event: content-delta\ndata: {"type":"content-delta","delta":{"message":{"content":{"text":"Hello"}}}}\n\n
 */
-function collapseCohereSSE(body) {
-	const blocks = splitSSEEvents(body);
+function collapseCohereSSE(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const blocks = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -696,14 +779,16 @@ function collapseCohereSSE(body) {
 			toolCalls: orderedBlocks ? orderedToolCalls : indexSortedToolCalls,
 			...reasoning ? { reasoning } : {},
 			...droppedChunks > 0 ? { droppedChunks } : {},
-			...firstDroppedSample ? { firstDroppedSample } : {}
+			...firstDroppedSample ? { firstDroppedSample } : {},
+			...inputTruncated ? { truncated: true } : {}
 		};
 	}
 	return {
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -797,8 +882,11 @@ function decodeEventStreamFrames(buf) {
 * Each frame contains a JSON payload with event types like:
 *   contentBlockDelta, contentBlockStart, etc.
 */
-function collapseBedrockEventStream(body) {
-	const { frames, truncated } = decodeEventStreamFrames(body);
+function collapseBedrockEventStream(rawBody) {
+	const limit = effectiveCollapseStringLimit();
+	const inputTruncated = rawBody.byteLength > limit;
+	const { frames, truncated: frameTruncated } = decodeEventStreamFrames(inputTruncated ? rawBody.subarray(0, limit) : rawBody);
+	const truncated = frameTruncated || inputTruncated;
 	let content = "";
 	let reasoning = "";
 	let reasoningSignature;
@@ -953,8 +1041,9 @@ function collapseBedrockEventStream(body) {
 * delta) are still accepted for backward compatibility with previously
 * recorded fixtures.
 */
-function collapseGeminiInteractionsSSE(body) {
-	const lines = splitSSEEvents(body);
+function collapseGeminiInteractionsSSE(rawBody) {
+	const inputTruncated = isCollapseInputTruncated(rawBody);
+	const lines = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
 	let reasoning = "";
 	let droppedChunks = 0;
@@ -1035,13 +1124,15 @@ function collapseGeminiInteractionsSSE(body) {
 		toolCalls,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 	return {
 		content,
 		...reasoning ? { reasoning } : {},
 		...droppedChunks > 0 ? { droppedChunks } : {},
-		...firstDroppedSample ? { firstDroppedSample } : {}
+		...firstDroppedSample ? { firstDroppedSample } : {},
+		...inputTruncated ? { truncated: true } : {}
 	};
 }
 /**
@@ -1073,5 +1164,5 @@ function collapseStreamingResponse(contentType, providerKey, body, logger) {
 }
 
 //#endregion
-export { capturedRedactedData, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse };
+export { MAX_COLLAPSE_STRING_LENGTH, capturedRedactedData, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse, setCollapseStringLimitForTests };
 //# sourceMappingURL=stream-collapse.js.map