@copilotkit/aimock 1.44.0 → 1.45.0

package/dist/stream-collapse.cjs

@@ -80,6 +80,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
@@ -101,7 +105,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 } : {}
 	};
 }
 /**
@@ -111,19 +148,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;
@@ -137,8 +186,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;
@@ -157,7 +208,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;
@@ -234,8 +285,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 = "";
@@ -296,14 +380,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({
@@ -313,15 +402,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({
@@ -331,11 +447,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: ""
@@ -346,15 +517,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
@@ -407,6 +579,7 @@ function collapseOpenAISSE(rawBody) {
 			lastToolCallKey = index;
 			if (!toolCallMap.has(index)) {
 				const created = {
+					kind: "function",
 					id: rawId ?? "",
 					name: fn?.name ?? "",
 					arguments: ""
@@ -420,11 +593,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 && require_harmony.isHarmonyContent(content)) {
+	if (!Array.from(toolCallMap.values()).some((tc) => tc.kind === "function") && require_harmony.isHarmonyContent(content)) {
 		const parsed = require_harmony.parseHarmonyContent(content);
 		if (parsed.failed) {
 			harmonyUnparsed = true;
@@ -435,18 +608,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,
@@ -456,6 +633,7 @@ function collapseOpenAISSE(rawBody) {
 			...blocks ? { blocks } : {},
 			...content ? { content } : {},
 			toolCalls: [...blocks ? orderedToolCalls : indexSortedToolCalls, ...harmonyToolCalls],
+			...customFields,
 			...reasoning ? { reasoning } : {},
 			...webSearchQueries.length > 0 ? { webSearches: webSearchQueries } : {},
 			...usage ? { usage } : {},
@@ -473,6 +651,7 @@ function collapseOpenAISSE(rawBody) {
 			...transcriptUsage ? { usage: transcriptUsage } : {}
 		} } : {},
 		content,
+		...customFields,
 		...reasoning ? { reasoning } : {},
 		...webSearchQueries.length > 0 ? { webSearches: webSearchQueries } : {},
 		...usage ? { usage } : {},
@@ -1011,6 +1190,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)}`;
@@ -1256,8 +1445,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"));
@@ -1267,7 +1467,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);
@@ -1276,7 +1476,7 @@ 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;
@@ -1293,5 +1493,7 @@ exports.collapseGeminiSSE = collapseGeminiSSE;
 exports.collapseOllamaNDJSON = collapseOllamaNDJSON;
 exports.collapseOpenAISSE = collapseOpenAISSE;
 exports.collapseStreamingResponse = collapseStreamingResponse;
+exports.collapseStreamingResponseWithResponsesTools = collapseStreamingResponseWithResponsesTools;
 exports.setCollapseStringLimitForTests = setCollapseStringLimitForTests;
+exports.withoutResponsesToolFields = withoutResponsesToolFields;
 //# sourceMappingURL=stream-collapse.cjs.map