@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/stream-collapse.d.cts

@@ -1,5 +1,5 @@
 import { Logger } from "./logger.cjs";
-import { FixtureBlock, RecordProviderKey, ToolCall } from "./types.cjs";
+import { CustomToolCall, FixtureBlock, RecordProviderKey, ResponsesFixtureBlock, ToolCall } from "./types.cjs";
 
 //#region src/stream-collapse.d.ts
 
@@ -71,7 +71,17 @@ interface CollapseResult {
    * `response.usage` override shape before persisting.
    */
   usage?: Record<string, unknown>;
+  /**
+   * Function calls. An OpenAI Responses `function_call` item's `namespace` is
+   * kept on its entry (internal {@link collapseOpenAISSEWithResponsesTools} only).
+   */
   toolCalls?: ToolCall[];
+  /**
+   * OpenAI Responses custom tool calls (`custom_tool_call` items), in output
+   * order (internal {@link collapseOpenAISSEWithResponsesTools} only). They are never part of `toolCalls`
+   * or `blocks`.
+   */
+  customToolCalls?: CustomToolCall[];
   droppedChunks?: number;
   firstDroppedSample?: string;
   truncated?: boolean;
@@ -100,10 +110,21 @@ interface CollapseResult {
    * keeps the legacy `{ content, toolCalls }` shape byte-identical.
    *
    * Each text block coalesces all contiguous content deltas between tool
-   * atoms; each toolCall block carries the fully-assembled name/arguments/id
-   * for one tool call in the position its FIRST delta arrived.
+   * atoms. Each tool block sits in the position where its FIRST delta arrived:
+   * a function call becomes a `toolCall` block with the fully-assembled
+   * name/arguments/id, and an OpenAI Responses custom call becomes a
+   * `customToolCall` block with name/input/id, where `input` is kept verbatim.
+   * Custom calls are left out of `blocks` (which, like `toolCalls`, describes
+   * function calls and text only); see {@link CollapseResult.responsesBlocks}.
    */
   blocks?: FixtureBlock[];
+  /**
+   * OpenAI Responses only: the full ordered output (text, function calls and
+   * custom calls) when the stream carried a custom call whose position the
+   * `content` + `toolCalls` + `customToolCalls` shape cannot express (it is
+   * interleaved with text, or comes before a function call).
+   */
+  responsesBlocks?: ResponsesFixtureBlock[];
 }
 /**
  * The opaque `data` of a non-empty Anthropic `redacted_thinking` block, or
@@ -121,8 +142,16 @@ interface CollapseResult {
  * Format:
  *   data: {"id":"chatcmpl-123","choices":[{"delta":{"content":"Hello"}}]}\n\n
  *   data: [DONE]\n\n
+ *
+ * Public, with the 1.44.0 result: an OpenAI Responses `namespace` and custom
+ * tool calls are dropped. The recorder uses {@link collapseOpenAISSEWithResponsesTools}.
  */
 declare function collapseOpenAISSE(rawBody: string): CollapseResult;
+/**
+ * A collapse result as 1.44.0 returned and recorded it: no `namespace` on a
+ * function call or `toolCall` block, and no custom tool calls.
+ */
+
 /**
  * Collapse Anthropic Claude Messages SSE stream into a single response.
  *
@@ -186,9 +215,15 @@ 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.
  * Falls back to OpenAI SSE parsing for unrecognized provider keys with text/event-stream.
+ *
+ * Public, with the 1.44.0 result (see {@link collapseOpenAISSE}). The recorder
+ * uses {@link collapseStreamingResponseWithResponsesTools}.
  */
 declare function collapseStreamingResponse(contentType: string, providerKey: RecordProviderKey, body: string | Buffer, logger?: Logger): CollapseResult | null;
-//# sourceMappingURL=stream-collapse.d.ts.map
+/**
+ * @internal {@link collapseStreamingResponse} keeping an OpenAI Responses
+ * `namespace` and custom tool calls.
+ */
 //#endregion
 export { CollapseResult, MAX_COLLAPSE_STRING_LENGTH, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse, setCollapseStringLimitForTests };
 //# sourceMappingURL=stream-collapse.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stream-collapse.d.cts","names":[],"sources":["../src/stream-collapse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA2XA;AAiaA;AAkMA;AAyJA;AAmIA;AA6RA;;;;;AA0RA;AAwLA;;;;;AAKG,cAx8DU,0BAw8DV,EAAA,MAAA;;iBA77Da,8BAAA;UAgDC,cAAA;;;;gBAID;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCF;cACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCH;;;;;;;;;;;;;;;;;;;iBA+MK,iBAAA,mBAAoC;;;;;;;;iBAiapC,oBAAA,mBAAuC;;;;;;;iBAkMvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAyJpC,oBAAA,mBAAuC;;;;;;;iBAmIvC,iBAAA,mBAAoC;;;;;;;iBA6RpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBA0R7C,6BAAA,mBAAgD;;;;;;iBAwLhD,yBAAA,mCAED,kCACE,iBACN,SACR"}
+{"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"}

package/dist/stream-collapse.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from "./logger.js";
-import { FixtureBlock, RecordProviderKey, ToolCall } from "./types.js";
+import { CustomToolCall, FixtureBlock, RecordProviderKey, ResponsesFixtureBlock, ToolCall } from "./types.js";
 
 //#region src/stream-collapse.d.ts
 
@@ -71,7 +71,17 @@ interface CollapseResult {
    * `response.usage` override shape before persisting.
    */
   usage?: Record<string, unknown>;
+  /**
+   * Function calls. An OpenAI Responses `function_call` item's `namespace` is
+   * kept on its entry (internal {@link collapseOpenAISSEWithResponsesTools} only).
+   */
   toolCalls?: ToolCall[];
+  /**
+   * OpenAI Responses custom tool calls (`custom_tool_call` items), in output
+   * order (internal {@link collapseOpenAISSEWithResponsesTools} only). They are never part of `toolCalls`
+   * or `blocks`.
+   */
+  customToolCalls?: CustomToolCall[];
   droppedChunks?: number;
   firstDroppedSample?: string;
   truncated?: boolean;
@@ -100,10 +110,21 @@ interface CollapseResult {
    * keeps the legacy `{ content, toolCalls }` shape byte-identical.
    *
    * Each text block coalesces all contiguous content deltas between tool
-   * atoms; each toolCall block carries the fully-assembled name/arguments/id
-   * for one tool call in the position its FIRST delta arrived.
+   * atoms. Each tool block sits in the position where its FIRST delta arrived:
+   * a function call becomes a `toolCall` block with the fully-assembled
+   * name/arguments/id, and an OpenAI Responses custom call becomes a
+   * `customToolCall` block with name/input/id, where `input` is kept verbatim.
+   * Custom calls are left out of `blocks` (which, like `toolCalls`, describes
+   * function calls and text only); see {@link CollapseResult.responsesBlocks}.
    */
   blocks?: FixtureBlock[];
+  /**
+   * OpenAI Responses only: the full ordered output (text, function calls and
+   * custom calls) when the stream carried a custom call whose position the
+   * `content` + `toolCalls` + `customToolCalls` shape cannot express (it is
+   * interleaved with text, or comes before a function call).
+   */
+  responsesBlocks?: ResponsesFixtureBlock[];
 }
 /**
  * The opaque `data` of a non-empty Anthropic `redacted_thinking` block, or
@@ -121,8 +142,16 @@ interface CollapseResult {
  * Format:
  *   data: {"id":"chatcmpl-123","choices":[{"delta":{"content":"Hello"}}]}\n\n
  *   data: [DONE]\n\n
+ *
+ * Public, with the 1.44.0 result: an OpenAI Responses `namespace` and custom
+ * tool calls are dropped. The recorder uses {@link collapseOpenAISSEWithResponsesTools}.
  */
 declare function collapseOpenAISSE(rawBody: string): CollapseResult;
+/**
+ * A collapse result as 1.44.0 returned and recorded it: no `namespace` on a
+ * function call or `toolCall` block, and no custom tool calls.
+ */
+
 /**
  * Collapse Anthropic Claude Messages SSE stream into a single response.
  *
@@ -186,9 +215,15 @@ 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.
  * Falls back to OpenAI SSE parsing for unrecognized provider keys with text/event-stream.
+ *
+ * Public, with the 1.44.0 result (see {@link collapseOpenAISSE}). The recorder
+ * uses {@link collapseStreamingResponseWithResponsesTools}.
  */
 declare function collapseStreamingResponse(contentType: string, providerKey: RecordProviderKey, body: string | Buffer, logger?: Logger): CollapseResult | null;
-//# sourceMappingURL=stream-collapse.d.ts.map
+/**
+ * @internal {@link collapseStreamingResponse} keeping an OpenAI Responses
+ * `namespace` and custom tool calls.
+ */
 //#endregion
 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":";;;;;;;;;AA2XA;AAiaA;AAkMA;AAyJA;AAmIA;AA6RA;;;;;AA0RA;AAwLA;;;;;AAKG,cAx8DU,0BAw8DV,EAAA,MAAA;;iBA77Da,8BAAA;UAgDC,cAAA;;;;gBAID;;;YACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCF;cACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCH;;;;;;;;;;;;;;;;;;;iBA+MK,iBAAA,mBAAoC;;;;;;;;iBAiapC,oBAAA,mBAAuC;;;;;;;iBAkMvC,iBAAA,mBAAoC;;;;;;;;;;;;;;;iBAyJpC,oBAAA,mBAAuC;;;;;;;iBAmIvC,iBAAA,mBAAoC;;;;;;;iBA6RpC,0BAAA,UAAoC,SAAS;;;;;;;;;;;;;;;iBA0R7C,6BAAA,mBAAgD;;;;;;iBAwLhD,yBAAA,mCAED,kCACE,iBACN,SACR"}
+{"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"}

package/dist/stream-collapse.js

@@ -79,6 +79,10 @@ function guardCollapseBody(body) {
 function isCollapseInputTruncated(body) {
 	return body.length > effectiveCollapseStringLimit();
 }
+/** A Responses `namespace` field when it is a non-empty string, else undefined. */
+function responsesNamespace(item) {
+	return typeof item.namespace === "string" && item.namespace !== "" ? item.namespace : void 0;
+}
 /**
 * Normalize a tool call's accumulated `arguments` into valid JSON exactly like
 * the flat-`toolCalls` recorder path: an empty / whitespace-only / missing
@@ -100,7 +104,40 @@ function toToolCallBlock(ref) {
 		type: "toolCall",
 		name: ref.name,
 		arguments: normalizeToolArguments(ref.arguments),
-		...ref.id ? { id: ref.id } : {}
+		...ref.id ? { id: ref.id } : {},
+		...ref.namespace ? { namespace: ref.namespace } : {}
+	};
+}
+/**
+* Build a `customToolCall` block from a custom-call accumulator. The `input` is
+* free text: it is kept as is, never normalized to `"{}"`.
+*/
+function toCustomToolCallBlock(ref) {
+	return {
+		type: "customToolCall",
+		name: ref.name,
+		input: ref.input,
+		...ref.id ? { id: ref.id } : {},
+		...ref.namespace ? { namespace: ref.namespace } : {}
+	};
+}
+/** Project a function-call accumulator to a flat fixture tool call. */
+function toFunctionToolCall(ref) {
+	return {
+		name: ref.name,
+		arguments: normalizeToolArguments(ref.arguments),
+		...ref.id ? { id: ref.id } : {},
+		...ref.namespace ? { namespace: ref.namespace } : {}
+	};
+}
+/** Project a custom-call accumulator to a flat fixture custom tool call. */
+function toCustomToolCall(ref) {
+	return {
+		type: "custom",
+		name: ref.name,
+		input: ref.input,
+		...ref.id ? { id: ref.id } : {},
+		...ref.namespace ? { namespace: ref.namespace } : {}
 	};
 }
 /**
@@ -110,19 +147,31 @@ function toToolCallBlock(ref) {
 * `CollapseResult.blocks` unset and the recorder keeps the legacy shape.
 *
 * Interleaved ⇔ (a tool atom appears strictly before the first text atom) OR
-* (a text atom appears after any tool atom). A stream with no tool atoms, or
+* (a text atom appears after any tool atom). Tool atoms are `toolCall` and
+* `customToolCall` atoms. A stream with no tool atoms, or
 * with no text atoms, is never interleaved. Text-first-then-tools is the common
 * legacy case and is explicitly NOT interleaved.
 *
-* CONSISTENCY (#274): each toolCall block is derived from the SAME accumulator
-* object referenced by its atom and normalized identically to the flat
-* `toolCalls` path ({@link toToolCallBlock} / {@link normalizeToolArguments}).
-* Because the atom `ref` is the very object the flat list is built from, the
-* block and its flat counterpart describe the same call by identity — even when
-* upstream tool-call indices do not match stream-arrival order. Empty/missing
-* arguments normalize to `"{}"` in BOTH representations, never `""`.
+* CONSISTENCY (#274): each tool block is derived from the SAME accumulator
+* object referenced by its atom. Because the atom `ref` is the very object the
+* flat list is built from, the block and its flat counterpart describe the same
+* call by identity — even when upstream tool-call indices do not match
+* stream-arrival order. A `toolCall` block is normalized identically to the
+* flat `toolCalls` path ({@link toToolCallBlock} / {@link normalizeToolArguments}):
+* empty/missing arguments become `"{}"` in BOTH representations, never `""`. A
+* `customToolCall` block ({@link toCustomToolCallBlock}) keeps `input` verbatim,
+* the same as the flat custom tool call ({@link toCustomToolCall}); it is never
+* normalized to `"{}"`.
 */
 function buildOrderedBlocks(atoms) {
+	return orderedBlocksFrom(atoms.filter((a) => a.kind !== "customToolCall"))?.filter((block) => block.type !== "customToolCall");
+}
+/**
+* {@link buildOrderedBlocks} over every atom, custom calls included, for
+* `CollapseResult.responsesBlocks`. With `force`, the blocks are built even
+* when text and tools are not interleaved.
+*/
+function orderedBlocksFrom(atoms, force = false) {
 	let firstTextIndex = -1;
 	let firstToolIndex = -1;
 	let textAfterTool = false;
@@ -136,8 +185,10 @@ function buildOrderedBlocks(atoms) {
 		sawTool = true;
 		if (firstToolIndex === -1) firstToolIndex = i;
 	}
-	if (!sawTool || !sawText) return void 0;
-	if (!(firstToolIndex < firstTextIndex) && !textAfterTool) return void 0;
+	if (!force) {
+		if (!sawTool || !sawText) return void 0;
+		if (!(firstToolIndex < firstTextIndex) && !textAfterTool) return void 0;
+	}
 	const blocks = [];
 	let pendingText = "";
 	let hasPendingText = false;
@@ -156,7 +207,7 @@ function buildOrderedBlocks(atoms) {
 		hasPendingText = true;
 	} else {
 		flushText();
-		blocks.push(toToolCallBlock(a.ref));
+		blocks.push(a.kind === "customToolCall" ? toCustomToolCallBlock(a.ref) : toToolCallBlock(a.ref));
 	}
 	flushText();
 	return blocks;
@@ -233,8 +284,41 @@ function extractSSEData(lines) {
 * Format:
 *   data: {"id":"chatcmpl-123","choices":[{"delta":{"content":"Hello"}}]}\n\n
 *   data: [DONE]\n\n
+*
+* Public, with the 1.44.0 result: an OpenAI Responses `namespace` and custom
+* tool calls are dropped. The recorder uses {@link collapseOpenAISSEWithResponsesTools}.
 */
 function collapseOpenAISSE(rawBody) {
+	return withoutResponsesToolFields(collapseOpenAISSEWithResponsesTools(rawBody));
+}
+/**
+* A collapse result as 1.44.0 returned and recorded it: no `namespace` on a
+* function call or `toolCall` block, and no custom tool calls.
+*/
+function withoutResponsesToolFields(collapsed) {
+	if (collapsed.customToolCalls === void 0 && collapsed.responsesBlocks === void 0 && !collapsed.toolCalls?.some((tc) => tc.namespace !== void 0) && !collapsed.blocks?.some((block) => block.type !== "text" && block.namespace !== void 0)) return collapsed;
+	const result = { ...collapsed };
+	delete result.customToolCalls;
+	delete result.responsesBlocks;
+	if (result.toolCalls) result.toolCalls = result.toolCalls.map((tc) => {
+		if (tc.namespace === void 0) return tc;
+		const copy = { ...tc };
+		delete copy.namespace;
+		return copy;
+	});
+	if (result.blocks) result.blocks = result.blocks.map((block) => {
+		if (block.type === "text" || block.namespace === void 0) return block;
+		const copy = { ...block };
+		delete copy.namespace;
+		return copy;
+	});
+	return result;
+}
+/**
+* @internal {@link collapseOpenAISSE} keeping an OpenAI Responses `namespace`
+* and custom tool calls, for the recorder with `responsesTools: "extended"`.
+*/
+function collapseOpenAISSEWithResponsesTools(rawBody) {
 	const inputTruncated = isCollapseInputTruncated(rawBody);
 	const lines = splitSSEEvents(guardCollapseBody(rawBody));
 	let content = "";
@@ -295,14 +379,19 @@ function collapseOpenAISSE(rawBody) {
 			if (item?.type === "function_call" && typeof parsed.output_index === "number") {
 				const entry = toolCallMap.get(parsed.output_index);
 				if (entry) {
-					if (!entry.id && typeof item.call_id === "string") entry.id = item.call_id;
-					if (!entry.name && typeof item.name === "string") entry.name = item.name;
-					if (entry.arguments === "" && typeof item.arguments === "string") entry.arguments = item.arguments;
+					if (entry.kind === "function") {
+						if (!entry.id && typeof item.call_id === "string") entry.id = item.call_id;
+						if (!entry.name && typeof item.name === "string") entry.name = item.name;
+						if (!entry.namespace) entry.namespace = responsesNamespace(item);
+						if (entry.arguments === "" && typeof item.arguments === "string") entry.arguments = item.arguments;
+					}
 				} else {
 					const created = {
+						kind: "function",
 						id: typeof item.call_id === "string" ? item.call_id : "",
 						name: typeof item.name === "string" ? item.name : "",
-						arguments: typeof item.arguments === "string" ? item.arguments : ""
+						arguments: typeof item.arguments === "string" ? item.arguments : "",
+						namespace: responsesNamespace(item)
 					};
 					toolCallMap.set(parsed.output_index, created);
 					orderAtoms.push({
@@ -312,15 +401,42 @@ function collapseOpenAISSE(rawBody) {
 				}
 				continue;
 			}
+			if (item?.type === "custom_tool_call" && typeof parsed.output_index === "number") {
+				const entry = toolCallMap.get(parsed.output_index);
+				if (entry) {
+					if (entry.kind === "custom") {
+						if (!entry.id && typeof item.call_id === "string") entry.id = item.call_id;
+						if (!entry.name && typeof item.name === "string") entry.name = item.name;
+						if (!entry.namespace) entry.namespace = responsesNamespace(item);
+						if (entry.input === "" && typeof item.input === "string") entry.input = item.input;
+					}
+				} else {
+					const created = {
+						kind: "custom",
+						id: typeof item.call_id === "string" ? item.call_id : "",
+						name: typeof item.name === "string" ? item.name : "",
+						input: typeof item.input === "string" ? item.input : "",
+						namespace: responsesNamespace(item)
+					};
+					toolCallMap.set(parsed.output_index, created);
+					orderAtoms.push({
+						kind: "customToolCall",
+						ref: created
+					});
+				}
+				continue;
+			}
 		}
 		if (parsed.type === "response.output_item.added") {
 			const item = parsed.item;
 			if (item?.type === "function_call" && typeof parsed.output_index === "number") {
 				if (!toolCallMap.has(parsed.output_index)) {
 					const created = {
+						kind: "function",
 						id: typeof item.call_id === "string" ? item.call_id : "",
 						name: typeof item.name === "string" ? item.name : "",
-						arguments: ""
+						arguments: "",
+						namespace: responsesNamespace(item)
 					};
 					toolCallMap.set(parsed.output_index, created);
 					orderAtoms.push({
@@ -330,11 +446,66 @@ function collapseOpenAISSE(rawBody) {
 				}
 				continue;
 			}
+			if (item?.type === "custom_tool_call" && typeof parsed.output_index === "number") {
+				if (!toolCallMap.has(parsed.output_index)) {
+					const created = {
+						kind: "custom",
+						id: typeof item.call_id === "string" ? item.call_id : "",
+						name: typeof item.name === "string" ? item.name : "",
+						input: "",
+						namespace: responsesNamespace(item)
+					};
+					toolCallMap.set(parsed.output_index, created);
+					orderAtoms.push({
+						kind: "customToolCall",
+						ref: created
+					});
+				}
+				continue;
+			}
+		}
+		if (parsed.type === "response.custom_tool_call_input.delta" && typeof parsed.delta === "string" && typeof parsed.output_index === "number") {
+			let entry = toolCallMap.get(parsed.output_index);
+			if (!entry) {
+				entry = {
+					kind: "custom",
+					id: "",
+					name: "",
+					input: ""
+				};
+				toolCallMap.set(parsed.output_index, entry);
+				orderAtoms.push({
+					kind: "customToolCall",
+					ref: entry
+				});
+			}
+			if (entry.kind === "custom") entry.input += parsed.delta;
+			continue;
+		}
+		if (parsed.type === "response.custom_tool_call_input.done" && typeof parsed.output_index === "number") {
+			const entry = toolCallMap.get(parsed.output_index);
+			if (entry) {
+				if (entry.kind === "custom" && entry.input === "" && typeof parsed.input === "string") entry.input = parsed.input;
+			} else if (typeof parsed.input === "string") {
+				const created = {
+					kind: "custom",
+					id: "",
+					name: "",
+					input: parsed.input
+				};
+				toolCallMap.set(parsed.output_index, created);
+				orderAtoms.push({
+					kind: "customToolCall",
+					ref: created
+				});
+			}
+			continue;
 		}
 		if (parsed.type === "response.function_call_arguments.delta" && typeof parsed.delta === "string" && typeof parsed.output_index === "number") {
 			let entry = toolCallMap.get(parsed.output_index);
 			if (!entry) {
 				entry = {
+					kind: "function",
 					id: "",
 					name: "",
 					arguments: ""
@@ -345,15 +516,16 @@ function collapseOpenAISSE(rawBody) {
 					ref: entry
 				});
 			}
-			entry.arguments += parsed.delta;
+			if (entry.kind === "function") entry.arguments += parsed.delta;
 			continue;
 		}
 		if (parsed.type === "response.function_call_arguments.done" && typeof parsed.output_index === "number") {
 			const entry = toolCallMap.get(parsed.output_index);
 			if (entry) {
-				if (entry.arguments === "" && typeof parsed.arguments === "string") entry.arguments = parsed.arguments;
+				if (entry.kind === "function" && entry.arguments === "" && typeof parsed.arguments === "string") entry.arguments = parsed.arguments;
 			} else if (typeof parsed.arguments === "string") {
 				const created = {
+					kind: "function",
 					id: "",
 					name: "",
 					arguments: parsed.arguments
@@ -406,6 +578,7 @@ function collapseOpenAISSE(rawBody) {
 			lastToolCallKey = index;
 			if (!toolCallMap.has(index)) {
 				const created = {
+					kind: "function",
 					id: rawId ?? "",
 					name: fn?.name ?? "",
 					arguments: ""
@@ -419,11 +592,11 @@ function collapseOpenAISSE(rawBody) {
 			const entry = toolCallMap.get(index);
 			if (fn?.name && typeof fn.name === "string" && !entry.name) entry.name = fn.name;
 			if (tc.id && typeof tc.id === "string" && !entry.id) entry.id = tc.id;
-			if (fn?.arguments && typeof fn.arguments === "string") entry.arguments += fn.arguments;
+			if (entry.kind === "function" && fn?.arguments && typeof fn.arguments === "string") entry.arguments += fn.arguments;
 		}
 	}
 	const harmonyToolCalls = [];
-	if (toolCallMap.size === 0 && isHarmonyContent(content)) {
+	if (!Array.from(toolCallMap.values()).some((tc) => tc.kind === "function") && isHarmonyContent(content)) {
 		const parsed = parseHarmonyContent(content);
 		if (parsed.failed) {
 			harmonyUnparsed = true;
@@ -434,18 +607,22 @@ function collapseOpenAISSE(rawBody) {
 			harmonyToolCalls.push(...parsed.toolCalls);
 		}
 	}
-	if (toolCallMap.size > 0 || harmonyToolCalls.length > 0) {
+	const sortedEntries = Array.from(toolCallMap.entries()).sort(([a], [b]) => a - b);
+	const customEntries = sortedEntries.flatMap(([, tc]) => tc.kind === "custom" ? [tc] : []);
+	const functionEntries = sortedEntries.flatMap(([, tc]) => tc.kind === "function" ? [tc] : []);
+	let customFields = {};
+	if (customEntries.length > 0) {
+		const firstCustomAtom = orderAtoms.findIndex((a) => a.kind === "customToolCall");
+		const responsesBlocks = orderedBlocksFrom(orderAtoms, orderAtoms.some((a, i) => a.kind === "toolCall" && i > firstCustomAtom));
+		customFields = {
+			customToolCalls: responsesBlocks ? orderAtoms.flatMap((a) => a.kind === "customToolCall" ? [toCustomToolCall(a.ref)] : []) : customEntries.map(toCustomToolCall),
+			...responsesBlocks ? { responsesBlocks } : {}
+		};
+	}
+	if (functionEntries.length > 0 || harmonyToolCalls.length > 0) {
 		const blocks = buildOrderedBlocks(orderAtoms);
-		const orderedToolCalls = orderAtoms.filter((a) => a.kind === "toolCall").map((a) => ({
-			name: a.ref.name,
-			arguments: normalizeToolArguments(a.ref.arguments),
-			...a.ref.id ? { id: a.ref.id } : {}
-		}));
-		const indexSortedToolCalls = Array.from(toolCallMap.entries()).sort(([a], [b]) => a - b).map(([, tc]) => ({
-			name: tc.name,
-			arguments: normalizeToolArguments(tc.arguments),
-			...tc.id ? { id: tc.id } : {}
-		}));
+		const orderedToolCalls = orderAtoms.flatMap((a) => a.kind === "toolCall" ? [toFunctionToolCall(a.ref)] : []);
+		const indexSortedToolCalls = functionEntries.map(toFunctionToolCall);
 		return {
 			...transcriptSeen ? { transcription: {
 				text: transcript,
@@ -455,6 +632,7 @@ function collapseOpenAISSE(rawBody) {
 			...blocks ? { blocks } : {},
 			...content ? { content } : {},
 			toolCalls: [...blocks ? orderedToolCalls : indexSortedToolCalls, ...harmonyToolCalls],
+			...customFields,
 			...reasoning ? { reasoning } : {},
 			...webSearchQueries.length > 0 ? { webSearches: webSearchQueries } : {},
 			...usage ? { usage } : {},
@@ -472,6 +650,7 @@ function collapseOpenAISSE(rawBody) {
 			...transcriptUsage ? { usage: transcriptUsage } : {}
 		} } : {},
 		content,
+		...customFields,
 		...reasoning ? { reasoning } : {},
 		...webSearchQueries.length > 0 ? { webSearches: webSearchQueries } : {},
 		...usage ? { usage } : {},
@@ -1010,6 +1189,16 @@ function collapseBedrockEventStream(rawBody) {
 		let parsed;
 		try {
 			parsed = JSON.parse(frameStr);
+			if (frame.headers[":event-type"] === "chunk" && parsed !== null && typeof parsed === "object" && Object.hasOwn(parsed, "bytes")) try {
+				const bytes = parsed.bytes;
+				if (typeof bytes !== "string" || bytes.length === 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(bytes)) throw new TypeError("bytes must be a nonempty base64 string");
+				const event = JSON.parse(Buffer.from(bytes, "base64").toString("utf8"));
+				if (event === null || typeof event !== "object" || Array.isArray(event) || !("type" in event) || typeof event.type !== "string") throw new TypeError("decoded bytes must contain a Claude event object");
+				parsed = event;
+			} catch (err) {
+				const message = err instanceof Error ? err.message : "unknown";
+				throw new TypeError(`Invalid Invoke PayloadPart: ${message}`);
+			}
 		} catch (err) {
 			droppedChunks++;
 			if (droppedChunks === 1) firstDroppedSample = `parse failed (${err instanceof Error ? err.message : "unknown"}): ${surrogateSafeSlice(frameStr, 200)}`;
@@ -1255,8 +1444,19 @@ function collapseGeminiInteractionsSSE(rawBody) {
 * Collapse a streaming response body into a non-streaming fixture response.
 * Returns null if the content type is not a known streaming format.
 * Falls back to OpenAI SSE parsing for unrecognized provider keys with text/event-stream.
+*
+* Public, with the 1.44.0 result (see {@link collapseOpenAISSE}). The recorder
+* uses {@link collapseStreamingResponseWithResponsesTools}.
 */
 function collapseStreamingResponse(contentType, providerKey, body, logger) {
+	const collapsed = collapseStreamingResponseWithResponsesTools(contentType, providerKey, body, logger);
+	return collapsed && withoutResponsesToolFields(collapsed);
+}
+/**
+* @internal {@link collapseStreamingResponse} keeping an OpenAI Responses
+* `namespace` and custom tool calls.
+*/
+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"));
@@ -1266,7 +1466,7 @@ function collapseStreamingResponse(contentType, providerKey, body, logger) {
 			case "openai":
 			case "azure":
 			case "openrouter":
-			case "byteplus": return collapseOpenAISSE(str);
+			case "byteplus": return collapseOpenAISSEWithResponsesTools(str);
 			case "anthropic": return collapseAnthropicSSE(str);
 			case "gemini":
 			case "vertexai": return collapseGeminiSSE(str);
@@ -1275,12 +1475,12 @@ function collapseStreamingResponse(contentType, providerKey, body, logger) {
 			case "bedrock": return collapseAnthropicSSE(str);
 			default:
 				logger?.warn(`[stream-collapse] unknown SSE provider "${providerKey}", falling back to OpenAI SSE format`);
-				return collapseOpenAISSE(str);
+				return collapseOpenAISSEWithResponsesTools(str);
 		}
 	}
 	return null;
 }
 
 //#endregion
-export { MAX_COLLAPSE_STRING_LENGTH, capturedRedactedData, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse, setCollapseStringLimitForTests };
+export { MAX_COLLAPSE_STRING_LENGTH, capturedRedactedData, collapseAnthropicSSE, collapseBedrockEventStream, collapseCohereSSE, collapseGeminiInteractionsSSE, collapseGeminiSSE, collapseOllamaNDJSON, collapseOpenAISSE, collapseStreamingResponse, collapseStreamingResponseWithResponsesTools, setCollapseStringLimitForTests, withoutResponsesToolFields };
 //# sourceMappingURL=stream-collapse.js.map