@tanstack/ai 0.57.0 → 0.59.0

package/dist/esm/activities/chat/stream/processor.js

@@ -1,9 +1,11 @@
+import { EventType } from "../../../types.js";
 import { mergeMetadata, tanstackMetadata } from "../../../utilities/merge-metadata.js";
 import { runErrorEventToError } from "../../../utilities/errors.js";
 import { INTERRUPT_BINDING_METADATA_KEY } from "../../../interrupt-resume.js";
 import { normalizeToolResult } from "../../../utilities/tool-result.js";
+import { splitSubagentWire } from "../../../utilities/subagent-wire.js";
 import { isProviderExecutedToolCall } from "../../../utilities/provider-executed.js";
-import { aguiSnapshotMessageToUIMessage, coerceCreatedAt, generateMessageId, uiMessageToModelMessages } from "../messages.js";
+import { aguiContentToContentParts, aguiSnapshotMessageToUIMessage, coerceCreatedAt, generateMessageId, uiMessageToModelMessages } from "../messages.js";
 import { getChunkRunId } from "../../../utilities/chunk-ids.js";
 import { defaultJSONParser } from "./json-parser.js";
 import { appendStructuredOutputDelta, completeStructuredOutputPart, errorStructuredOutputPart, updateTextPart, updateThinkingPart, updateToolCallApproval, updateToolCallApprovalResponse, updateToolCallPart, updateToolCallWithOutput, updateToolResultPart } from "./message-updaters.js";
@@ -67,13 +69,17 @@ var StreamProcessor = class StreamProcessor {
 	structuredMessageIds = /* @__PURE__ */ new Set();
 	structuredOutputUpdateBatches = /* @__PURE__ */ new Map();
 	activeRuns = /* @__PURE__ */ new Set();
+	childProcessors = /* @__PURE__ */ new Map();
+	childToolCalls = /* @__PURE__ */ new Map();
 	finishReason = null;
 	hasError = false;
 	isDone = false;
 	streamEndEmitted = false;
 	recording = null;
 	recordingStartTime = 0;
+	subagentRunId;
 	constructor(options = {}) {
+		this.subagentRunId = options.subagentRunId;
 		this.chunkStrategy = options.chunkStrategy || new ImmediateStrategy();
 		this.events = options.events || {};
 		this.jsonParser = options.jsonParser || defaultJSONParser;
@@ -192,6 +198,11 @@ var StreamProcessor = class StreamProcessor {
 	addToolResult(toolCallId, output, error) {
 		const messageWithToolCall = this.messages.find((msg) => msg.parts.some((p) => p.type === "tool-call" && p.id === toolCallId));
 		if (!messageWithToolCall) {
+			const owner = this.childOwningToolCall((part) => part.id === toolCallId);
+			if (owner !== void 0) {
+				this.updateChild(owner, (child) => child.addToolResult(toolCallId, output, error));
+				return;
+			}
 			console.warn(`[StreamProcessor] Could not find message with tool call ${toolCallId}`);
 			return;
 		}
@@ -206,6 +217,11 @@ var StreamProcessor = class StreamProcessor {
 	* Add an approval response (called by client after handling onApprovalRequest)
 	*/
 	addToolApprovalResponse(approvalId, approved) {
+		const owner = this.childOwningToolCall((part) => part.approval?.id === approvalId);
+		if (owner !== void 0) {
+			this.updateChild(owner, (child) => child.addToolApprovalResponse(approvalId, approved));
+			return;
+		}
 		this.messages = updateToolCallApprovalResponse(this.messages, approvalId, approved);
 		this.emitMessagesChange();
 	}
@@ -259,6 +275,8 @@ var StreamProcessor = class StreamProcessor {
 		this.structuredMessageIds.clear();
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
+		this.childProcessors.clear();
+		this.childToolCalls.clear();
 		this.emitMessagesChange();
 	}
 	/**
@@ -287,7 +305,17 @@ var StreamProcessor = class StreamProcessor {
 			timestamp: Date.now(),
 			index: this.recording.chunks.length
 		});
+		if (this.routeToChild(chunk)) return;
 		switch (chunk.type) {
+			case "SUBAGENT_STARTED":
+				this.handleSubagentStartedEvent(chunk);
+				break;
+			case "SUBAGENT_FINISHED":
+				this.handleSubagentFinishedEvent(chunk);
+				break;
+			case "SUBAGENT_ERROR":
+				this.handleSubagentErrorEvent(chunk);
+				break;
 			case "TEXT_MESSAGE_START":
 				this.handleTextMessageStartEvent(chunk);
 				break;
@@ -497,6 +525,164 @@ var StreamProcessor = class StreamProcessor {
 		} : msg);
 		this.emitMessagesChange();
 	}
+	findSubagentPart(subagentRunId) {
+		for (const message of this.messages) for (const part of message.parts) if (part.type === "subagent" && part.subagent.id === subagentRunId) return {
+			message,
+			part
+		};
+	}
+	/**
+	* The direct child whose card holds `id`: the child itself, or a nested
+	* child inside its messages.
+	*/
+	childOwning(id) {
+		const holds = (messages) => messages.some((message) => message.parts.some((part) => part.type === "subagent" && (part.subagent.id === id || holds(part.subagent.messages))));
+		for (const message of this.messages) for (const part of message.parts) {
+			if (part.type !== "subagent") continue;
+			if (part.subagent.id === id || holds(part.subagent.messages)) return part.subagent.id;
+		}
+	}
+	/** The direct child whose messages hold this tool call. */
+	childOwningToolCall(matches) {
+		const holds = (messages) => messages.some((message) => message.parts.some((part) => part.type === "tool-call" && matches(part) || part.type === "subagent" && holds(part.subagent.messages)));
+		for (const message of this.messages) for (const part of message.parts) if (part.type === "subagent" && holds(part.subagent.messages)) return part.subagent.id;
+	}
+	/**
+	* The processor for a direct child. The card's messages are the source of
+	* truth. The processor re-reads them when something else replaced them.
+	*/
+	childProcessor(subagentRunId) {
+		const found = this.findSubagentPart(subagentRunId);
+		if (!found) return void 0;
+		const messages = found.part.subagent.messages;
+		const existing = this.childProcessors.get(subagentRunId);
+		if (existing) {
+			if (existing.getMessages() !== messages) existing.messages = messages;
+			return existing;
+		}
+		const child = new StreamProcessor({
+			subagentRunId,
+			initialMessages: messages,
+			events: {
+				onToolCall: (args) => this.events.onToolCall?.(args),
+				onApprovalRequest: (args) => this.events.onApprovalRequest?.(args),
+				onCustomEvent: (name, value, context) => this.events.onCustomEvent?.(name, value, context)
+			}
+		});
+		this.childProcessors.set(subagentRunId, child);
+		return child;
+	}
+	/** Run `update` on a direct child, then copy its messages onto the card. */
+	updateChild(subagentRunId, update) {
+		const child = this.childProcessor(subagentRunId);
+		if (!child) return;
+		update(child);
+		const messages = child.getMessages();
+		this.patchSubagent(subagentRunId, (subagent) => {
+			subagent.messages = messages;
+		});
+	}
+	handleSubagentStartedEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_STARTED") return;
+		if (this.findSubagentPart(chunk.subagentRunId)) {
+			this.childProcessors.delete(chunk.subagentRunId);
+			this.patchSubagent(chunk.subagentRunId, (subagent) => {
+				subagent.status = "running";
+				delete subagent.interruptIds;
+				delete subagent.error;
+				if (chunk.metadata !== void 0) subagent.metadata = chunk.metadata;
+			});
+			return;
+		}
+		const { messageId } = this.ensureAssistantMessage();
+		const part = {
+			type: "subagent",
+			subagent: {
+				id: chunk.subagentRunId,
+				name: chunk.name,
+				...chunk.description !== void 0 && { description: chunk.description },
+				status: "running",
+				...chunk.parentSubagentRunId !== void 0 && { parentSubagentRunId: chunk.parentSubagentRunId },
+				...chunk.parentToolCallId !== void 0 && { parentToolCallId: chunk.parentToolCallId },
+				...chunk.metadata !== void 0 && { metadata: chunk.metadata },
+				messages: []
+			}
+		};
+		this.messages = this.messages.map((message) => message.id === messageId ? {
+			...message,
+			parts: [...message.parts, part]
+		} : message);
+		this.emitMessagesChange();
+	}
+	handleSubagentFinishedEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_FINISHED") return;
+		this.updateChild(chunk.subagentRunId, (child) => child.finalizeStream());
+		this.patchSubagent(chunk.subagentRunId, (subagent) => {
+			if (subagent.status === "error") return;
+			if (chunk.outcome?.type === "suspended") {
+				subagent.status = "suspended";
+				subagent.interruptIds = chunk.outcome.interruptIds ?? [];
+				return;
+			}
+			subagent.status = "finished";
+		});
+	}
+	handleSubagentErrorEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_ERROR") return;
+		this.updateChild(chunk.subagentRunId, (child) => child.finalizeStream());
+		this.patchSubagent(chunk.subagentRunId, (subagent) => {
+			subagent.status = "error";
+			subagent.error = {
+				message: chunk.message,
+				...chunk.code !== void 0 && { code: chunk.code }
+			};
+		});
+	}
+	patchSubagent(subagentRunId, patch) {
+		this.messages = this.messages.map((message) => {
+			const index = message.parts.findIndex((part) => part.type === "subagent" && part.subagent.id === subagentRunId);
+			if (index === -1) return message;
+			const part = message.parts[index];
+			if (!part || part.type !== "subagent") return message;
+			const next = {
+				type: "subagent",
+				subagent: { ...part.subagent }
+			};
+			patch(next.subagent);
+			const parts = [...message.parts];
+			parts[index] = next;
+			return {
+				...message,
+				parts
+			};
+		});
+		this.emitMessagesChange();
+	}
+	/**
+	* Send a child's chunk to that child's processor, so the card keeps text,
+	* reasoning, tool calls, results, and nested children. A tool event without
+	* `subagentRunId` follows its `TOOL_CALL_START`.
+	*/
+	routeToChild(chunk) {
+		let id;
+		if (chunk.type === "SUBAGENT_STARTED") id = chunk.parentSubagentRunId;
+		else if (chunk.type === "SUBAGENT_FINISHED" || chunk.type === "SUBAGENT_ERROR") {
+			if (this.findSubagentPart(chunk.subagentRunId)) return false;
+			id = chunk.subagentRunId;
+		} else if ("subagentRunId" in chunk && chunk.subagentRunId) id = chunk.subagentRunId;
+		else if ("toolCallId" in chunk && typeof chunk.toolCallId === "string") id = this.childToolCalls.get(chunk.toolCallId);
+		if (id === void 0) return false;
+		const owner = this.childOwning(id);
+		if (owner === void 0) {
+			if (id === this.subagentRunId) return false;
+			console.warn(`[StreamProcessor] Dropped a chunk for unknown subagent ${id}`);
+			return true;
+		}
+		if (this.findSubagentPart(owner)?.part.subagent.status === "error") return true;
+		if (chunk.type === "TOOL_CALL_START") this.childToolCalls.set(chunk.toolCallId, owner);
+		this.updateChild(owner, (child) => child.processChunk(chunk));
+		return true;
+	}
 	/**
 	* Handle TEXT_MESSAGE_START event
 	*/
@@ -579,8 +765,9 @@ var StreamProcessor = class StreamProcessor {
 		this.resetStreamState();
 		const prevMessages = this.messages;
 		const prevById = new Map(prevMessages.map((msg) => [msg.id, msg]));
-		const normalized = this.mergeReasoningFanOut(chunk.messages.map(aguiSnapshotMessageToUIMessage));
-		this.messages = this.reconcileSnapshotToolCalls(normalized, prevMessages).map((msg) => {
+		const { top, groups } = splitSubagentWire(chunk.messages);
+		const normalized = this.mergeReasoningFanOut(top.map(aguiSnapshotMessageToUIMessage));
+		const reconciled = this.reconcileSnapshotToolCalls(normalized, prevMessages).map((msg) => {
 			if (msg.metadata != null) return msg;
 			const prev = prevById.get(msg.id);
 			if (prev?.metadata == null) return msg;
@@ -589,9 +776,76 @@ var StreamProcessor = class StreamProcessor {
 				metadata: prev.metadata
 			};
 		});
+		this.messages = this.attachSnapshotSubagents(reconciled, top, groups, prevMessages);
 		this.emitMessagesChange();
 	}
 	/**
+	* Put subagent cards back on a snapshot. Child wire messages (tagged with
+	* `subagentRunId`) become a card on the nearest assistant message before
+	* them, or a new assistant message when there is none. A card that the
+	* snapshot does not carry stays on its message, because a server snapshot
+	* can hold the parent history only.
+	*/
+	attachSnapshotSubagents(messages, top, groups, prevMessages) {
+		const cards = [];
+		const children = /* @__PURE__ */ new Map();
+		for (const group of groups) {
+			const child = new StreamProcessor({ subagentRunId: group.id });
+			child.processChunk({
+				type: EventType.MESSAGES_SNAPSHOT,
+				messages: group.messages,
+				timestamp: Date.now()
+			});
+			children.set(group.id, child);
+			const { placeholder: _placeholder, ...info } = group.info;
+			cards.push({
+				hostId: top.slice(0, group.hostIndex + 1).findLast((message) => message.role === "assistant")?.id,
+				part: {
+					type: "subagent",
+					subagent: {
+						...info,
+						id: group.id,
+						messages: child.getMessages()
+					}
+				},
+				carried: false
+			});
+		}
+		const inSnapshot = new Set(groups.map((group) => group.id));
+		for (const message of prevMessages) for (const part of message.parts) {
+			if (part.type !== "subagent" || inSnapshot.has(part.subagent.id)) continue;
+			cards.push({
+				hostId: message.id,
+				...part.subagent.parentToolCallId !== void 0 && { toolCallId: part.subagent.parentToolCallId },
+				part,
+				carried: true
+			});
+			const kept = this.childProcessors.get(part.subagent.id);
+			if (kept) children.set(part.subagent.id, kept);
+		}
+		this.childProcessors.clear();
+		for (const [id, child] of children) this.childProcessors.set(id, child);
+		let out = messages;
+		for (const card of cards) {
+			let index = out.findIndex((message) => message.id === card.hostId);
+			if (index === -1 && card.toolCallId !== void 0) index = out.findIndex((message) => message.parts.some((part) => part.type === "tool-call" && part.id === card.toolCallId));
+			if (index === -1 && !card.carried) index = out.findLastIndex((message) => message.role === "assistant");
+			if (index === -1) {
+				if (!card.carried) out = [...out, {
+					id: generateMessageId(),
+					role: "assistant",
+					parts: [card.part]
+				}];
+				continue;
+			}
+			out = out.map((message, position) => position !== index || message.parts.some((part) => part.type === "subagent" && part.subagent.id === card.part.subagent.id) ? message : {
+				...message,
+				parts: [...message.parts, card.part]
+			});
+		}
+		return out;
+	}
+	/**
 	* Reconcile a freshly normalized snapshot with the pre-snapshot message
 	* state so unreconstructable tool-call metadata is preserved.
 	*
@@ -901,13 +1155,13 @@ var StreamProcessor = class StreamProcessor {
 		const isOutputError = chunk.state === "output-error" || tanstackMetadata(chunk)?.state === "output-error";
 		let output;
 		try {
-			output = JSON.parse(chunk.content);
+			output = typeof chunk.content === "string" ? JSON.parse(chunk.content) : chunk.content;
 		} catch {
 			output = chunk.content;
 		}
 		this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output, isOutputError ? "error" : void 0);
 		const resultState = isOutputError ? "error" : "complete";
-		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.content, resultState, resultState === "error" ? this.extractToolResultError(output) : void 0);
+		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, aguiContentToContentParts(chunk.content), resultState, resultState === "error" ? this.extractToolResultError(output) : void 0);
 		this.emitMessagesChange();
 	}
 	/**
@@ -941,21 +1195,38 @@ var StreamProcessor = class StreamProcessor {
 			this.finalizeStream();
 		}
 	}
-	handleInterrupts(interrupts) {
+	/**
+	* Apply interrupt state to tool-call parts, then fire the client events.
+	* A child's interrupt updates the child's card. `emit` is false there, so
+	* the events fire once, from the top processor.
+	*/
+	handleInterrupts(interrupts, emit = true) {
 		const hasGeneric = interruptBatchHasGeneric(interrupts);
 		for (const interrupt of interrupts) {
 			const metadata = interrupt.metadata && typeof interrupt.metadata === "object" ? interrupt.metadata : {};
 			const kind = typeof metadata.kind === "string" ? metadata.kind : void 0;
 			const toolCallId = interrupt.toolCallId;
 			if (!toolCallId) continue;
+			const owner = interrupt.subagentRunId !== void 0 ? this.childOwning(interrupt.subagentRunId) : this.childOwningToolCall((part) => part.id === toolCallId);
+			if (owner !== void 0) this.updateChild(owner, (child) => child.handleInterrupts([interrupt], false));
 			const toolName = typeof metadata.toolName === "string" ? metadata.toolName : this.findToolCallName(toolCallId);
 			const input = Object.hasOwn(metadata, "input") ? metadata.input : {};
 			if (kind === "approval" || interrupt.reason === "approval_required") {
+				if (owner !== void 0) {
+					if (emit) this.events.onApprovalRequest?.({
+						toolCallId,
+						toolName,
+						input,
+						approvalId: interrupt.id
+					});
+					continue;
+				}
 				const resolvedMessageId = this.getActiveAssistantMessageId() ?? this.toolCallToMessage.get(toolCallId) ?? this.messages.find((m) => m.role === "assistant" && m.parts.some((p) => p.type === "tool-call" && p.id === toolCallId))?.id;
 				if (resolvedMessageId) {
 					this.messages = updateToolCallApproval(this.messages, resolvedMessageId, toolCallId, interrupt.id);
 					this.emitMessagesChange();
 				}
+				if (!emit) continue;
 				this.events.onApprovalRequest?.({
 					toolCallId,
 					toolName,
@@ -965,7 +1236,7 @@ var StreamProcessor = class StreamProcessor {
 				continue;
 			}
 			if (kind === "client_tool" || interrupt.reason === "client_tool_input") {
-				if (hasGeneric) continue;
+				if (hasGeneric || !emit) continue;
 				this.events.onToolCall?.({
 					toolCallId,
 					toolName,
@@ -1473,6 +1744,8 @@ var StreamProcessor = class StreamProcessor {
 	reset() {
 		this.resetStreamState();
 		this.messages = [];
+		this.childProcessors.clear();
+		this.childToolCalls.clear();
 	}
 	/**
 	* Check if a message contains only whitespace text and no other meaningful parts