@mastra/react 0.0.0-studio-cli-20260504022012 → 0.0.0-sugared-octave-20261030170102

package/dist/accumulator-Bjfckb5t.cjs

@@ -0,0 +1,1753 @@
+// src/agent/signal-data.ts
+const uint8ArrayToBase64 = (bytes) => {
+	const chunkSize = 32768;
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += chunkSize) binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+	return btoa(binary);
+};
+function convertSignalDataToBase64String(content) {
+	if (typeof content === "string") return content;
+	const bytes = content instanceof ArrayBuffer ? new Uint8Array(content) : content;
+	return uint8ArrayToBase64(bytes);
+}
+/** Canonical DB `file` part `data` for optimistic UI and memory-shaped storage. */
+function encodeFilePartDataForStorage(data, mimeType) {
+	if (typeof data === "string") return data;
+	if (data instanceof URL) return data.toString();
+	const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+	const base64 = uint8ArrayToBase64(bytes);
+	if (base64.startsWith("data:")) return base64;
+	return `data:${mimeType};base64,${base64}`;
+}
+// src/lib/mastra-db/formatCompletionFeedback.ts
+const formatBaseCompletionFeedback = (result, maxIterationReached, formatScorerHeading, incompleteMessage) => {
+	const lines = [];
+	lines.push("#### Completion Check Results");
+	lines.push("");
+	lines.push(`Overall: ${result.complete ? "✅ COMPLETE" : "❌ NOT COMPLETE"}`);
+	lines.push(`Duration: ${result.totalDuration}ms`);
+	if (result.timedOut) lines.push("⚠️ Scoring timed out");
+	lines.push("");
+	for (const scorer of result.scorers) {
+		lines.push(formatScorerHeading(scorer));
+		lines.push(`Score: ${scorer.score} ${scorer.passed ? "✅" : "❌"}`);
+		if (scorer.reason) lines.push(`Reason: ${scorer.reason}`);
+		lines.push("");
+	}
+	if (result.complete) lines.push("✅ The task is complete.");
+	else if (maxIterationReached) lines.push("⚠️ Max iterations reached.");
+	else lines.push(incompleteMessage);
+	return lines.join("\n");
+};
+const formatCompletionFeedback = (result, maxIterationReached) => {
+	return formatBaseCompletionFeedback(result, maxIterationReached, (scorer) => `###### ${scorer.scorerName} (${scorer.scorerId})`, "🔄 Will continue working on the task.");
+};
+const formatStreamCompletionFeedback = (result, maxIterationReached) => {
+	return formatBaseCompletionFeedback(result, maxIterationReached, (scorer) => `**${scorer.scorerName}** (${scorer.scorerId})`, "🔄 The task is not yet complete. Please continue working based on the feedback above.");
+};
+// src/lib/mastra-db/types.ts
+/**
+* Canonical metadata block stored under `MastraDBMessage.content.metadata`.
+*
+* Every UX hint the React accumulator needs to surface lives here. Mode-specific
+* fields are all optional so a single record can carry the union without forcing
+* narrowing on the consumer side.
+*/
+/**
+* Metadata key carrying a client-generated correlation id. The optimistic
+* pending user bubble and the outgoing `sendMessage` request both stamp this
+* id; the server echoes it back on the `data-user-message` data part so the
+* accumulator can reconcile the pending bubble deterministically (decoupled
+* from the server-assigned signal id). This is transient client state and is
+* stripped once the echo is reconciled and on reload.
+*/
+const CLIENT_MESSAGE_ID_KEY = "clientMessageId";
+// src/lib/mastra-db/accumulator.ts
+function toolErrorText(error) {
+	if (error && typeof error === "object") {
+		if ("message" in error && typeof error.message === "string") return error.message;
+		if ("cause" in error) {
+			const cause = error.cause;
+			if (cause && typeof cause === "object") {
+				if (("id" in cause ? cause.id : "code" in cause ? cause.code : void 0) === "AGENT_AGENT_TOOL_EXECUTION_FAILED" && "message" in cause && typeof cause.message === "string") return cause.message;
+			}
+		}
+	}
+	return String(error);
+}
+/**
+* Agent-as-tool boundaries wrap progressive chunks in nested `tool-output`
+* envelopes. Peel only agent boundaries; workflow/tool envelopes remain the
+* leaf so existing child-message accumulation can process them normally.
+*/
+const normalizeNestedAgentOutput = (output) => {
+	const boundaries = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = output;
+	while (current !== null && typeof current === "object") {
+		if (seen.has(current)) return void 0;
+		seen.add(current);
+		const chunk = current;
+		if (chunk.type !== "tool-output") return {
+			leaf: current,
+			boundaries
+		};
+		const toolCallId = chunk.payload?.toolCallId;
+		const toolName = chunk.payload?.toolName;
+		if (typeof toolName !== "string" || !toolName.startsWith("agent-")) return {
+			leaf: current,
+			boundaries
+		};
+		if (typeof toolCallId !== "string" || !("output" in (chunk.payload ?? {}))) return void 0;
+		boundaries.push({
+			toolCallId,
+			toolName
+		});
+		current = chunk.payload?.output;
+	}
+};
+const cloneMetadata = (metadata) => metadata ? { ...metadata } : {};
+const withParts = (message, parts) => ({
+	...message,
+	content: {
+		...message.content,
+		parts
+	}
+});
+const withMetadata = (message, metadata) => ({
+	...message,
+	content: {
+		...message.content,
+		metadata
+	}
+});
+const clearPendingStatus = (message) => {
+	const { status: _status, queued: _queued, [CLIENT_MESSAGE_ID_KEY]: _clientMessageId, ...rest } = message.content.metadata ?? {};
+	return withMetadata(message, rest);
+};
+const clearPendingStatusKeepClientId = (message) => {
+	const { status: _status, queued: _queued, ...rest } = message.content.metadata ?? {};
+	return withMetadata(message, rest);
+};
+const replaceLast = (conversation, message) => [...conversation.slice(0, -1), message];
+const replaceAt = (conversation, index, message) => [
+	...conversation.slice(0, index),
+	message,
+	...conversation.slice(index + 1)
+];
+const newAssistantMessage = (id, parts, metadata) => ({
+	id,
+	role: "assistant",
+	createdAt: /* @__PURE__ */ new Date(),
+	content: {
+		format: 2,
+		parts,
+		metadata: cloneMetadata(metadata)
+	}
+});
+const appendAssistantMessage = (conversation, id, parts, metadata) => [...conversation, newAssistantMessage(id, parts, metadata)];
+const isToolPart = (part) => part.type === "tool-invocation";
+const partTextId = (part) => part.type === "text" ? part.textId : void 0;
+const partState = (part) => part.state;
+/**
+* Set any streaming text/reasoning parts on the trailing assistant message to
+* `state: 'done'`. Mirrors the previous `finishStreamingAssistantMessage` from
+* the AI-SDK accumulator.
+*/
+const finishStreamingAssistantMessage = (conversation) => {
+	const lastMessage = conversation[conversation.length - 1];
+	if (!lastMessage || lastMessage.role !== "assistant") return conversation;
+	if (lastMessage.content.parts.length === 0) return conversation.slice(0, -1);
+	const nextParts = lastMessage.content.parts.map((part) => {
+		if ((part.type === "text" || part.type === "reasoning") && partState(part) === "streaming") return {
+			...part,
+			state: "done"
+		};
+		return part;
+	});
+	return replaceLast(conversation, withParts(lastMessage, nextParts));
+};
+/**
+* Locate the assistant message + tool part owning `toolCallId`. Prefers the
+* most recent assistant message and walks back up to 10 messages, matching the
+* historical accumulator's lookup behavior.
+*/
+const locateToolPart = (messages, toolCallId, allowMetadataOnlyMatch) => {
+	const findIndex = (parts) => parts.findIndex((part) => isToolPart(part) && part.toolInvocation.toolCallId === toolCallId);
+	const lastMessage = messages[messages.length - 1];
+	if (lastMessage && lastMessage.role === "assistant") {
+		const idx = findIndex(lastMessage.content.parts);
+		if (idx !== -1) return {
+			messageIndex: messages.length - 1,
+			toolPartIndex: idx
+		};
+	}
+	let count = 0;
+	const maxMessagesBack = 10;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (count > maxMessagesBack) break;
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		const idx = findIndex(message.content.parts);
+		if (idx !== -1) return {
+			messageIndex: i,
+			toolPartIndex: idx
+		};
+		count++;
+	}
+	if (!allowMetadataOnlyMatch) return null;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "assistant") return {
+		messageIndex: i,
+		toolPartIndex: -1
+	};
+	return null;
+};
+/**
+* Merge per-toolCallId background-task bookkeeping onto message metadata.
+*/
+const mergeBgTaskMetadata = (existing, mode, args, otherMetadata) => {
+	const base = cloneMetadata(existing);
+	const existingBgTasks = base.backgroundTasks ?? {};
+	const nextBgTasks = { ...existingBgTasks };
+	if (args.perTaskEntry) {
+		const { toolCallId, startedAt, completedAt, taskId, suspendedAt } = args.perTaskEntry;
+		nextBgTasks[toolCallId] = {
+			...existingBgTasks[toolCallId] ?? { taskId },
+			taskId,
+			...startedAt !== void 0 ? { startedAt } : {},
+			...completedAt !== void 0 ? { completedAt } : {},
+			...suspendedAt !== void 0 ? { suspendedAt } : {}
+		};
+	}
+	const merged = {
+		...base,
+		...otherMetadata ?? {},
+		mode,
+		backgroundTasks: nextBgTasks
+	};
+	if (args.resetRunningCount) merged.runningBackgroundTasksCount = void 0;
+	return merged;
+};
+/**
+* Workflow chunk accumulation. Mirrors
+* `mapWorkflowStreamChunkToWatchResult` from the previous accumulator.
+*/
+const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+	const previous = prev && typeof prev === "object" && prev.steps && typeof prev.steps === "object" ? prev : {
+		status: "running",
+		input: void 0,
+		steps: {}
+	};
+	if (chunk.type === "workflow-start") return {
+		input: previous.input,
+		status: "running",
+		steps: previous.steps
+	};
+	if (chunk.type === "workflow-canceled") return {
+		...previous,
+		status: "canceled"
+	};
+	if (chunk.type === "workflow-paused") return {
+		...previous,
+		status: "paused"
+	};
+	if (chunk.type === "workflow-finish") {
+		const finalStatus = chunk.payload.workflowStatus;
+		const lastStep = Object.values(previous.steps).pop();
+		return {
+			...previous,
+			status: chunk.payload.workflowStatus,
+			...finalStatus === "success" && lastStep?.status === "success" ? { result: lastStep?.output } : finalStatus === "failed" && lastStep?.status === "failed" ? { error: lastStep?.error } : finalStatus === "tripwire" && chunk.payload.tripwire ? { tripwire: chunk.payload.tripwire } : {}
+		};
+	}
+	const stepId = chunk.payload?.id;
+	if (stepId === void 0) return previous;
+	const { stepCallId: _stepCallId, stepName: _stepName, ...newPayload } = chunk.payload;
+	const newSteps = {
+		...previous.steps,
+		[stepId]: {
+			...previous.steps[stepId],
+			...newPayload
+		}
+	};
+	if (chunk.type === "workflow-step-start") return {
+		...previous,
+		steps: newSteps
+	};
+	if (chunk.type === "workflow-step-suspended") {
+		const suspended = Object.entries(newSteps).flatMap(([stepId, stepResult]) => {
+			if (stepResult?.status === "suspended") {
+				const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
+				return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
+			}
+			return [];
+		});
+		return {
+			...previous,
+			status: "suspended",
+			steps: newSteps,
+			suspendPayload: chunk.payload.suspendPayload,
+			suspended
+		};
+	}
+	if (chunk.type === "workflow-step-waiting") return {
+		...previous,
+		status: "waiting",
+		steps: newSteps
+	};
+	if (chunk.type === "workflow-step-progress") return {
+		...previous,
+		steps: {
+			...previous.steps,
+			[stepId]: {
+				...previous.steps[stepId],
+				foreachProgress: {
+					completedCount: chunk.payload.completedCount,
+					totalCount: chunk.payload.totalCount,
+					currentIndex: chunk.payload.currentIndex,
+					iterationStatus: chunk.payload.iterationStatus,
+					iterationOutput: chunk.payload.iterationOutput
+				}
+			}
+		}
+	};
+	if (chunk.type === "workflow-step-result") return {
+		...previous,
+		steps: newSteps
+	};
+	return previous;
+};
+const signalContentsToUserMessages = (contents, metadata) => {
+	const makeUserMessage = (parts) => ({
+		id: `signal-${Date.now()}`,
+		role: "user",
+		createdAt: /* @__PURE__ */ new Date(),
+		content: {
+			format: 2,
+			parts,
+			metadata: cloneMetadata(metadata)
+		}
+	});
+	const toMessagePart = (part) => {
+		if (!part || typeof part !== "object") return [];
+		const typedPart = part;
+		if (typedPart.type === "text" && typeof typedPart.text === "string") return [{
+			type: "text",
+			text: typedPart.text
+		}];
+		if (typedPart.type === "image") {
+			const image = typedPart.image;
+			const mimeType = typeof typedPart.mediaType === "string" ? typedPart.mediaType : typeof typedPart.mimeType === "string" ? typedPart.mimeType : "image/*";
+			if (typeof image === "string" || image instanceof URL || image instanceof ArrayBuffer || image instanceof Uint8Array) return [{
+				type: "file",
+				mimeType,
+				data: encodeFilePartDataForStorage(image, mimeType)
+			}];
+			return [{
+				type: "file",
+				mimeType,
+				data: ""
+			}];
+		}
+		if (typedPart.type === "file") {
+			const data = typedPart.data;
+			const mimeType = typeof typedPart.mediaType === "string" ? typedPart.mediaType : typeof typedPart.mimeType === "string" ? typedPart.mimeType : "application/octet-stream";
+			if (typeof data === "string" || data instanceof URL || data instanceof ArrayBuffer || data instanceof Uint8Array) return [{
+				type: "file",
+				mimeType,
+				data: encodeFilePartDataForStorage(data, mimeType),
+				...typeof typedPart.filename === "string" ? { filename: typedPart.filename } : {}
+			}];
+			return [{
+				type: "file",
+				mimeType,
+				data: typeof typedPart.url === "string" ? typedPart.url : "",
+				...typeof typedPart.filename === "string" ? { filename: typedPart.filename } : {}
+			}];
+		}
+		return [];
+	};
+	if (typeof contents === "string") return [makeUserMessage([{
+		type: "text",
+		text: contents
+	}])];
+	if (Array.isArray(contents)) {
+		const parts = contents.flatMap(toMessagePart);
+		return parts.length ? [makeUserMessage(parts)] : contents.flatMap((content) => signalContentsToUserMessages(content, metadata));
+	}
+	if (!contents || typeof contents !== "object") return [];
+	const message = contents;
+	if (message.role && message.role !== "user") return [];
+	const content = message.content;
+	if (typeof content === "string") return [makeUserMessage([{
+		type: "text",
+		text: content
+	}])];
+	if (!Array.isArray(content)) return [];
+	const parts = content.flatMap(toMessagePart);
+	return parts.length ? [makeUserMessage(parts)] : [];
+};
+const reconcilePendingUserEcho = (message, echoedContents, metadata, options) => {
+	const echoedParts = signalContentsToUserMessages(echoedContents, metadata)[0]?.content.parts;
+	let reconciled = typeof options.signalId === "string" ? {
+		...message,
+		id: options.signalId
+	} : message;
+	if (echoedParts?.length) reconciled = {
+		...reconciled,
+		content: {
+			...reconciled.content,
+			parts: echoedParts
+		}
+	};
+	return options.keepClientMessageId ? clearPendingStatusKeepClientId(reconciled) : clearPendingStatus(reconciled);
+};
+const makeToolInvocationPart = (invocation) => ({
+	type: "tool-invocation",
+	toolInvocation: invocation
+});
+/**
+* Narrow the chunk to the template-literal passthrough variants from
+* `NetworkChunkType`. Encoded as a type guard so the surrounding `switch`
+* statement can stay exhaustive over the remaining string-literal cases.
+*/
+const isTemplateLiteralPassthrough = (chunk) => chunk.type.startsWith("agent-execution-event-") || chunk.type.startsWith("workflow-execution-event-");
+/**
+* Narrow the chunk to the `data-${string}` family. Used so the trailing
+* exhaustiveness check can prove the switch covers every remaining variant.
+*/
+const isDataChunk = (chunk) => chunk.type.startsWith("data-");
+/**
+* Reduce a single stream chunk into the running `MastraDBMessage[]`
+* conversation. The accumulator owns the entire chunk→DB mapping for the
+* React SDK; consumers downstream (e.g. `toAISdkV5Messages` in the playground)
+* translate the result into AI SDK / assistant-ui shapes as needed.
+*/
+const isQueuedUserBubble = (message) => message.role === "user" && message.content.metadata?.queued === true;
+const isUserMessagePendingChunk = (chunk) => chunk.type === "data-user-message-pending";
+const isUserMessageCancelledChunk = (chunk) => chunk.type === "data-user-message-cancelled";
+const accumulateChunk = ({ chunk, conversation, metadata }) => {
+	const result = [...conversation];
+	if (isUserMessageCancelledChunk(chunk)) return result.filter((message) => !(message.id === chunk.data.id && message.content.metadata?.status === "pending"));
+	const isQueuedChunk = isUserMessagePendingChunk(chunk) && chunk.data.metadata.status === "queued";
+	const queuedTailLength = (() => {
+		let count = 0;
+		while (count < result.length && isQueuedUserBubble(result[result.length - 1 - count])) count++;
+		return count;
+	})();
+	if (!isQueuedChunk && queuedTailLength > 0) {
+		const echoedId = isDataChunk(chunk) && chunk.type === "data-user-message" ? chunk.data?.id : void 0;
+		const tailStart = result.length - queuedTailLength;
+		const queuedTail = result.slice(tailStart).filter((message) => message.id !== echoedId);
+		return [...accumulateChunk({
+			chunk,
+			conversation: result.slice(0, tailStart),
+			metadata
+		}), ...queuedTail];
+	}
+	if (isUserMessagePendingChunk(chunk)) {
+		const { id, contents, metadata: signalMetadata } = chunk.data;
+		const clientId = signalMetadata[CLIENT_MESSAGE_ID_KEY];
+		const existing = result.find((message) => message.id === id || typeof clientId === "string" && message.content.metadata?.["clientMessageId"] === clientId);
+		if (existing) {
+			if (existing.content.metadata?.status !== "pending") return result;
+			return result.map((message) => message === existing ? {
+				...message,
+				id,
+				content: {
+					...message.content,
+					metadata: {
+						...message.content.metadata,
+						...signalMetadata.status === "queued" ? { queued: true } : {}
+					}
+				}
+			} : message);
+		}
+		const pendingMessages = signalContentsToUserMessages(contents, {
+			...metadata,
+			status: "pending",
+			...typeof clientId === "string" ? { [CLIENT_MESSAGE_ID_KEY]: clientId } : {},
+			...signalMetadata.status === "queued" ? { queued: true } : {}
+		});
+		return [...result, ...pendingMessages.map((message, index) => ({
+			...message,
+			id: index === 0 ? id : `${id}-${index}`
+		}))];
+	}
+	if (isTemplateLiteralPassthrough(chunk)) return result;
+	if (isDataChunk(chunk)) {
+		if (chunk.type === "data-user-message" && "data" in chunk && (chunk.data?.type === "user-message" || chunk.data?.type === "user")) {
+			const signalId = chunk.data.id;
+			const echoedClientMessageId = chunk.data?.metadata?.[CLIENT_MESSAGE_ID_KEY];
+			if (typeof echoedClientMessageId === "string" && result.some((message) => message.content.metadata?.status === "pending" && message.content.metadata["clientMessageId"] === echoedClientMessageId)) return finishStreamingAssistantMessage(result.map((message) => message.content.metadata?.status === "pending" && message.content.metadata["clientMessageId"] === echoedClientMessageId ? reconcilePendingUserEcho(message, chunk.data.contents, metadata, {
+				signalId: typeof signalId === "string" ? signalId : void 0,
+				keepClientMessageId: true
+			}) : message));
+			if (typeof signalId === "string" && result.some((message) => message.id === signalId)) return finishStreamingAssistantMessage(result.map((message) => message.id === signalId && message.content.metadata?.status === "pending" ? reconcilePendingUserEcho(message, chunk.data.contents, metadata, { keepClientMessageId: false }) : message));
+			const userMessages = signalContentsToUserMessages(chunk.data.contents, metadata);
+			if (!userMessages.length) return result;
+			const conversationWithFinishedAssistant = finishStreamingAssistantMessage(result);
+			const messageIdPrefix = typeof signalId === "string" ? signalId : `signal-${chunk.runId}-${Date.now()}`;
+			return [...conversationWithFinishedAssistant, ...userMessages.map((message, index) => ({
+				...message,
+				id: index === 0 ? messageIdPrefix : `${messageIdPrefix}-${index}`
+			}))];
+		}
+		const dataPart = {
+			type: chunk.type,
+			data: "data" in chunk ? chunk.data : void 0,
+			..."id" in chunk && typeof chunk.id === "string" ? { id: chunk.id } : {}
+		};
+		const lastMessage = result[result.length - 1];
+		if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `data-${chunk.runId}-${Date.now()}`, [dataPart], metadata);
+		return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, dataPart]));
+	}
+	switch (chunk.type) {
+		case "tripwire": {
+			const newMessage = newAssistantMessage(`tripwire-${chunk.runId + Date.now()}`, [{
+				type: "text",
+				text: chunk.payload.reason
+			}], {
+				...metadata,
+				status: "tripwire",
+				tripwire: {
+					reason: chunk.payload.reason,
+					retry: chunk.payload.retry,
+					metadata: chunk.payload.metadata,
+					processorId: chunk.payload.processorId
+				}
+			});
+			return [...result, newMessage];
+		}
+		case "start": {
+			const messageId = typeof chunk.payload?.messageId === "string" ? chunk.payload.messageId : void 0;
+			if (messageId && result.some((message) => message.id === messageId)) return result;
+			return [...result, newAssistantMessage(messageId ?? `start-${chunk.runId + Date.now()}`, [], metadata)];
+		}
+		case "text-start": {
+			const lastMessage = result[result.length - 1];
+			const textId = chunk.payload.id || `text-${Date.now()}`;
+			const tailPart = lastMessage?.content.parts[lastMessage.content.parts.length - 1];
+			if (chunk.payload.id && lastMessage?.role === "assistant" && tailPart?.type === "text" && partTextId(tailPart) === textId) return result;
+			const newTextPart = {
+				type: "text",
+				text: "",
+				state: "streaming",
+				textId,
+				providerMetadata: chunk.payload.providerMetadata
+			};
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `start-${chunk.runId}-${Date.now()}`, [newTextPart], metadata);
+			if (lastMessage.content.metadata?.completionResult) return appendAssistantMessage(result, `start-${chunk.runId}-${Date.now()}`, [newTextPart], metadata);
+			return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newTextPart]));
+		}
+		case "background-task-progress": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			return replaceLast(result, withMetadata(lastMessage, {
+				mode: metadata.mode,
+				...lastMessage.content.metadata,
+				runningBackgroundTasksCount: chunk.payload.runningCount
+			}));
+		}
+		case "text-delta": {
+			const lastMessage = result[result.length - 1];
+			const textId = chunk.payload.id;
+			if (!lastMessage || lastMessage.role !== "assistant") {
+				const newTextPart = {
+					type: "text",
+					text: chunk.payload.text,
+					state: "streaming",
+					textId,
+					providerMetadata: chunk.payload.providerMetadata
+				};
+				return appendAssistantMessage(result, `text-${chunk.runId}-${Date.now()}`, [newTextPart], metadata);
+			}
+			const parts = [...lastMessage.content.parts];
+			let textPartIndex = textId ? parts.findLastIndex((part) => part.type === "text" && partTextId(part) === textId) : -1;
+			if (textPartIndex === -1) textPartIndex = parts.findLastIndex((part) => part.type === "text" && partState(part) === "streaming");
+			if (textPartIndex !== -1 && parts.some((part, index) => index > textPartIndex && part.type !== "text")) textPartIndex = -1;
+			if (textPartIndex === -1) {
+				const newTextPart = {
+					type: "text",
+					text: chunk.payload.text,
+					state: "streaming",
+					textId,
+					providerMetadata: chunk.payload.providerMetadata
+				};
+				parts.push(newTextPart);
+			} else {
+				const textPart = parts[textPartIndex];
+				parts[textPartIndex] = {
+					...textPart,
+					text: textPart.text + chunk.payload.text,
+					state: "streaming"
+				};
+			}
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "text-end": return result;
+		case "reasoning-start": {
+			const lastMessage = result[result.length - 1];
+			const newReasoningPart = {
+				type: "reasoning",
+				reasoning: "",
+				state: "streaming",
+				providerMetadata: chunk.payload.providerMetadata
+			};
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `reasoning-${chunk.runId + Date.now()}`, [newReasoningPart], metadata);
+			return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newReasoningPart]));
+		}
+		case "reasoning-delta": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") {
+				const newReasoningPart = {
+					type: "reasoning",
+					reasoning: chunk.payload.text,
+					state: "streaming",
+					providerMetadata: chunk.payload.providerMetadata
+				};
+				return appendAssistantMessage(result, `reasoning-${chunk.runId + Date.now()}`, [newReasoningPart], metadata);
+			}
+			const parts = [...lastMessage.content.parts];
+			const lastIndex = parts.length - 1;
+			const lastPart = parts[lastIndex];
+			if (lastPart?.type === "reasoning") {
+				const reasoningPart = lastPart;
+				parts[lastIndex] = {
+					...reasoningPart,
+					reasoning: reasoningPart.reasoning + chunk.payload.text,
+					state: "streaming"
+				};
+			} else {
+				const newReasoningPart = {
+					type: "reasoning",
+					reasoning: chunk.payload.text,
+					state: "streaming",
+					providerMetadata: chunk.payload.providerMetadata
+				};
+				parts.push(newReasoningPart);
+			}
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "reasoning-end": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			const parts = [...lastMessage.content.parts];
+			const reasoningIndex = parts.findLastIndex((part) => part.type === "reasoning" && partState(part) === "streaming");
+			if (reasoningIndex === -1) return result;
+			const reasoningPart = parts[reasoningIndex];
+			const existingMeta = reasoningPart.providerMetadata;
+			const endMeta = chunk.payload.providerMetadata;
+			parts[reasoningIndex] = {
+				...reasoningPart,
+				state: "done",
+				...existingMeta || endMeta ? { providerMetadata: {
+					...existingMeta ?? {},
+					...endMeta ?? {}
+				} } : {}
+			};
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "reasoning-signature": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			const parts = [...lastMessage.content.parts];
+			const reasoningIndex = parts.findLastIndex((part) => part.type === "reasoning");
+			if (reasoningIndex === -1) return result;
+			const reasoningPart = parts[reasoningIndex];
+			const existingMeta = reasoningPart.providerMetadata;
+			const sigMeta = chunk.payload.providerMetadata;
+			parts[reasoningIndex] = {
+				...reasoningPart,
+				...existingMeta || sigMeta ? { providerMetadata: {
+					...existingMeta ?? {},
+					...sigMeta ?? {}
+				} } : {}
+			};
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "redacted-reasoning": {
+			const lastMessage = result[result.length - 1];
+			const redactedData = chunk.payload.data;
+			const redactedPart = {
+				type: "reasoning",
+				reasoning: typeof redactedData === "string" ? redactedData : "",
+				state: "done",
+				redacted: true,
+				providerMetadata: chunk.payload.providerMetadata
+			};
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `redacted-reasoning-${chunk.runId + Date.now()}`, [redactedPart], metadata);
+			return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, redactedPart]));
+		}
+		case "tool-call": {
+			const invocation = {
+				state: "call",
+				toolCallId: chunk.payload.toolCallId,
+				toolName: chunk.payload.toolName,
+				args: chunk.payload.args
+			};
+			const newPart = {
+				...makeToolInvocationPart(invocation),
+				title: chunk.payload.title,
+				providerMetadata: chunk.payload.providerMetadata
+			};
+			const existing = locateToolPart(result, chunk.payload.toolCallId, false);
+			if (existing && existing.toolPartIndex >= 0) {
+				const { messageIndex, toolPartIndex } = existing;
+				const targetMessage = result[messageIndex];
+				if (targetMessage && targetMessage.role === "assistant") {
+					const parts = [...targetMessage.content.parts];
+					const prev = parts[toolPartIndex];
+					if (isToolPart(prev)) {
+						const { argsText: _argsText, ...rest } = prev;
+						parts[toolPartIndex] = {
+							...rest,
+							toolInvocation: {
+								...prev.toolInvocation,
+								state: "call",
+								toolName: chunk.payload.toolName,
+								toolCallId: chunk.payload.toolCallId,
+								args: chunk.payload.args
+							},
+							title: chunk.payload.title ?? prev.title,
+							providerMetadata: chunk.payload.providerMetadata ?? prev.providerMetadata
+						};
+						return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+					}
+				}
+			}
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `tool-call-${chunk.runId + Date.now()}`, [newPart], metadata);
+			return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newPart]));
+		}
+		case "tool-call-input-streaming-start": {
+			const lastMessage = result[result.length - 1];
+			const invocation = {
+				state: "partial-call",
+				toolCallId: chunk.payload.toolCallId,
+				toolName: chunk.payload.toolName,
+				args: {}
+			};
+			const newPart = {
+				...makeToolInvocationPart(invocation),
+				title: chunk.payload.title,
+				argsText: ""
+			};
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, `tool-call-streaming-${chunk.runId + Date.now()}`, [newPart], metadata);
+			return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newPart]));
+		}
+		case "tool-call-delta": {
+			const location = locateToolPart(result, chunk.payload.toolCallId, false);
+			if (!location || location.toolPartIndex < 0) return result;
+			const { messageIndex, toolPartIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const parts = [...targetMessage.content.parts];
+			const toolPart = parts[toolPartIndex];
+			if (!isToolPart(toolPart)) return result;
+			const nextArgsText = (toolPart.argsText ?? "") + (chunk.payload.argsTextDelta ?? "");
+			parts[toolPartIndex] = {
+				...toolPart,
+				argsText: nextArgsText,
+				toolInvocation: {
+					...toolPart.toolInvocation,
+					state: "partial-call"
+				}
+			};
+			return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+		}
+		case "tool-call-input-streaming-end": {
+			const location = locateToolPart(result, chunk.payload.toolCallId, false);
+			if (!location || location.toolPartIndex < 0) return result;
+			const { messageIndex, toolPartIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const parts = [...targetMessage.content.parts];
+			const toolPart = parts[toolPartIndex];
+			if (!isToolPart(toolPart)) return result;
+			let parsedArgs = {};
+			const argsText = toolPart.argsText;
+			if (typeof argsText === "string" && argsText.length > 0) try {
+				const maybe = JSON.parse(argsText);
+				if (maybe && typeof maybe === "object" && !Array.isArray(maybe)) parsedArgs = maybe;
+			} catch {
+				parsedArgs = {};
+			}
+			parts[toolPartIndex] = {
+				...toolPart,
+				toolInvocation: {
+					...toolPart.toolInvocation,
+					state: "call",
+					args: parsedArgs
+				}
+			};
+			return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+		}
+		case "tool-output-denied": {
+			const location = locateToolPart(result, chunk.payload.toolCallId, false);
+			if (!location || location.toolPartIndex < 0) return result;
+			const { messageIndex, toolPartIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const parts = [...targetMessage.content.parts];
+			const toolPart = parts[toolPartIndex];
+			if (!isToolPart(toolPart)) return result;
+			parts[toolPartIndex] = {
+				...toolPart,
+				toolInvocation: {
+					...toolPart.toolInvocation,
+					state: "output-denied",
+					toolName: chunk.payload.toolName,
+					args: chunk.payload.args ?? toolPart.toolInvocation.args,
+					approval: chunk.payload.approval
+				}
+			};
+			return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+		}
+		case "tool-error":
+		case "tool-result":
+		case "background-task-completed":
+		case "background-task-failed": {
+			const isBgTaskEvent = chunk.type === "background-task-completed" || chunk.type === "background-task-failed";
+			const location = locateToolPart(result, chunk.payload.toolCallId, isBgTaskEvent);
+			if (!location) return result;
+			const { messageIndex, toolPartIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const parts = [...targetMessage.content.parts];
+			const toolPart = toolPartIndex >= 0 ? parts[toolPartIndex] : void 0;
+			let payloadResult;
+			let payloadError;
+			let payloadIsError = false;
+			let payloadProviderMetadata;
+			let payloadCompletedAt;
+			let payloadTaskId;
+			switch (chunk.type) {
+				case "tool-result":
+					payloadResult = chunk.payload.result;
+					payloadIsError = Boolean(chunk.payload.isError);
+					payloadProviderMetadata = chunk.payload.providerMetadata;
+					break;
+				case "tool-error":
+					payloadError = chunk.payload.error;
+					payloadProviderMetadata = chunk.payload.providerMetadata;
+					break;
+				case "background-task-completed":
+					payloadResult = chunk.payload.result;
+					payloadCompletedAt = chunk.payload.completedAt;
+					payloadTaskId = chunk.payload.taskId;
+					break;
+				case "background-task-failed":
+					payloadError = chunk.payload.error;
+					payloadCompletedAt = chunk.payload.completedAt;
+					payloadTaskId = chunk.payload.taskId;
+			}
+			if (toolPart && isToolPart(toolPart)) {
+				const { toolName, toolCallId, args } = toolPart.toolInvocation;
+				const providerMeta = payloadProviderMetadata ?? toolPart.providerMetadata;
+				if (chunk.type === "tool-error" || chunk.type === "background-task-failed" || payloadIsError) {
+					const errorText = toolErrorText(chunk.type === "tool-error" || chunk.type === "background-task-failed" ? payloadError : payloadResult);
+					parts[toolPartIndex] = {
+						...toolPart,
+						providerMetadata: providerMeta,
+						toolInvocation: {
+							state: "output-error",
+							toolCallId,
+							toolName,
+							args,
+							errorText,
+							...chunk.from === "AGENT" ? { result: toolPart.toolInvocation.result } : {}
+						}
+					};
+				} else {
+					const resultObj = payloadResult;
+					const existingResult = toolPart.toolInvocation.state === "partial-call" || toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
+					const existingLooksLikeWorkflow = Boolean(existingResult && typeof existingResult === "object" && "steps" in existingResult);
+					const isWorkflow = Boolean(resultObj?.result?.steps) || toolName?.startsWith("workflow-") || existingLooksLikeWorkflow;
+					const isAgent = chunk.from === "AGENT";
+					let output;
+					if (isWorkflow) {
+						const accumulated = existingLooksLikeWorkflow && existingResult && typeof existingResult === "object" ? existingResult : void 0;
+						const payloadWorkflow = resultObj?.result && typeof resultObj.result === "object" ? resultObj.result : void 0;
+						if (accumulated || payloadWorkflow) output = {
+							...accumulated ?? {},
+							...payloadWorkflow ?? {},
+							steps: payloadWorkflow?.steps ?? accumulated?.steps ?? [],
+							status: payloadWorkflow?.status ?? accumulated?.status ?? "success",
+							output: payloadResult
+						};
+						else output = payloadResult;
+					} else if (isAgent) {
+						const existingOutput = toolPart.toolInvocation.state === "partial-call" || toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
+						const existingChild = existingOutput?.childMessages;
+						output = existingOutput ? {
+							...payloadResult,
+							childMessages: existingChild?.length ? existingChild : resultObj?.childMessages
+						} : payloadResult;
+					} else output = payloadResult;
+					parts[toolPartIndex] = {
+						...toolPart,
+						providerMetadata: providerMeta,
+						toolInvocation: {
+							state: "result",
+							toolCallId,
+							toolName,
+							args,
+							result: output
+						}
+					};
+				}
+			}
+			const nextMetadata = mergeBgTaskMetadata(targetMessage.content.metadata, metadata.mode, {
+				resetRunningCount: isBgTaskEvent,
+				perTaskEntry: isBgTaskEvent && payloadTaskId ? {
+					toolCallId: chunk.payload.toolCallId,
+					completedAt: payloadCompletedAt,
+					taskId: payloadTaskId
+				} : void 0
+			});
+			const nextMessage = {
+				...targetMessage,
+				content: {
+					...targetMessage.content,
+					parts,
+					metadata: nextMetadata
+				}
+			};
+			return replaceAt(result, messageIndex, nextMessage);
+		}
+		case "background-task-running": {
+			const location = locateToolPart(result, chunk.payload.toolCallId, true);
+			if (!location) return result;
+			const { messageIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const nextMetadata = mergeBgTaskMetadata(targetMessage.content.metadata, metadata.mode, { perTaskEntry: {
+				toolCallId: chunk.payload.toolCallId,
+				startedAt: chunk.payload.startedAt,
+				taskId: chunk.payload.taskId
+			} });
+			return replaceAt(result, messageIndex, withMetadata(targetMessage, nextMetadata));
+		}
+		case "tool-output":
+		case "background-task-output": {
+			const isBgTaskOutput = chunk.type === "background-task-output";
+			const location = locateToolPart(result, chunk.payload.toolCallId, isBgTaskOutput);
+			if (!location || location.toolPartIndex < 0) return result;
+			const { messageIndex, toolPartIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const parts = [...targetMessage.content.parts];
+			const toolPart = parts[toolPartIndex];
+			if (!isToolPart(toolPart)) return result;
+			const { toolName, toolCallId, args } = toolPart.toolInvocation;
+			const payloadOutput = chunk.type === "background-task-output" ? chunk.payload.payload.payload.output : chunk.payload.output;
+			if (payloadOutput?.type?.startsWith("workflow-")) {
+				const existingWorkflowState = toolPart.toolInvocation.result;
+				const updated = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, payloadOutput);
+				parts[toolPartIndex] = {
+					...toolPart,
+					toolInvocation: {
+						state: "partial-call",
+						toolCallId,
+						toolName,
+						args,
+						result: updated
+					}
+				};
+			} else if (toolName.startsWith("agent-") || payloadOutput?.from === "AGENT") {
+				const normalized = normalizeNestedAgentOutput(payloadOutput);
+				if (!normalized) return result;
+				const { leaf, boundaries } = normalized;
+				if (leaf.from === "AGENT" || leaf.type === "tool-output" && leaf.payload?.output?.type?.startsWith("workflow-")) return accumulateAgentChunk(leaf, result, metadata, toolCallId, toolName, boundaries);
+				return result;
+			} else {
+				const currentResult = toolPart.toolInvocation.result;
+				const existing = Array.isArray(currentResult) ? currentResult : [];
+				parts[toolPartIndex] = {
+					...toolPart,
+					toolInvocation: {
+						state: "partial-call",
+						toolCallId,
+						toolName,
+						args,
+						result: [...existing, payloadOutput]
+					}
+				};
+			}
+			return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+		}
+		case "is-task-complete": {
+			if (chunk.payload.suppressFeedback) return result;
+			const feedback = formatStreamCompletionFeedback({
+				complete: chunk.payload.passed,
+				scorers: chunk.payload.results,
+				totalDuration: chunk.payload.duration,
+				timedOut: chunk.payload.timedOut,
+				completionReason: chunk.payload.reason
+			}, chunk.payload.maxIterationReached);
+			const newMessage = newAssistantMessage(`is-task-complete-${chunk.runId + Date.now()}`, [{
+				type: "text",
+				text: feedback
+			}], {
+				...metadata,
+				completionResult: { passed: chunk.payload.passed }
+			});
+			return [...result, newMessage];
+		}
+		case "source": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			const parts = [...lastMessage.content.parts];
+			if (chunk.payload.sourceType === "url") {
+				const sourceUrlPart = {
+					type: "source-url",
+					sourceId: chunk.payload.id,
+					url: chunk.payload.url || "",
+					title: chunk.payload.title,
+					providerMetadata: chunk.payload.providerMetadata
+				};
+				parts.push(sourceUrlPart);
+			} else if (chunk.payload.sourceType === "document") parts.push({
+				type: "source-document",
+				sourceId: chunk.payload.id,
+				mediaType: chunk.payload.mimeType || "application/octet-stream",
+				title: chunk.payload.title,
+				filename: chunk.payload.filename,
+				providerMetadata: chunk.payload.providerMetadata
+			});
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "file": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			const parts = [...lastMessage.content.parts];
+			let data;
+			if (typeof chunk.payload.data === "string") data = chunk.payload.base64 ? `data:${chunk.payload.mimeType};base64,${chunk.payload.data}` : `data:${chunk.payload.mimeType},${encodeURIComponent(chunk.payload.data)}`;
+			else {
+				const base64 = uint8ArrayToBase64(chunk.payload.data);
+				data = `data:${chunk.payload.mimeType};base64,${base64}`;
+			}
+			parts.push({
+				type: "file",
+				mimeType: chunk.payload.mimeType,
+				data,
+				providerMetadata: chunk.payload.providerMetadata
+			});
+			return replaceLast(result, withParts(lastMessage, parts));
+		}
+		case "tool-call-approval": {
+			const lastMessage = result[result.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant") return result;
+			const existingMeta = lastMessage.content.metadata ?? {};
+			const lastRequireApproval = existingMeta.mode === "stream" ? existingMeta.requireApprovalMetadata ?? {} : {};
+			return replaceLast(result, {
+				...lastMessage,
+				content: {
+					...lastMessage.content,
+					metadata: {
+						...existingMeta,
+						mode: "stream",
+						requireApprovalMetadata: {
+							...lastRequireApproval,
+							[chunk.payload.toolCallId]: {
+								toolCallId: chunk.payload.toolCallId,
+								toolName: chunk.payload.toolName,
+								args: chunk.payload.args
+							}
+						}
+					}
+				}
+			});
+		}
+		case "tool-call-suspended":
+		case "background-task-suspended": {
+			const isBgTaskEvent = chunk.type === "background-task-suspended";
+			let suspToolCallId;
+			let suspToolName;
+			let suspArgs;
+			let suspPayload;
+			let suspSuspendedAt;
+			let suspTaskId;
+			if (chunk.type === "background-task-suspended") {
+				suspToolCallId = chunk.payload.toolCallId;
+				suspToolName = chunk.payload.toolName;
+				suspArgs = chunk.payload.args;
+				suspPayload = chunk.payload.suspendPayload;
+				suspSuspendedAt = chunk.payload.suspendedAt;
+				suspTaskId = chunk.payload.taskId;
+			} else {
+				suspToolCallId = chunk.payload.toolCallId;
+				suspToolName = chunk.payload.toolName;
+				suspArgs = chunk.payload.args;
+				suspPayload = chunk.payload.suspendPayload;
+			}
+			const location = isBgTaskEvent ? locateToolPart(result, suspToolCallId, true) : { messageIndex: result.length - 1 };
+			if (!location) return result;
+			const { messageIndex } = location;
+			const targetMessage = result[messageIndex];
+			if (!targetMessage || targetMessage.role !== "assistant") return result;
+			const existingMeta = targetMessage.content.metadata ?? {};
+			const lastSuspendedTools = existingMeta.mode === "stream" ? existingMeta.suspendedTools ?? {} : {};
+			const nextMetadata = mergeBgTaskMetadata(existingMeta, "stream", {
+				resetRunningCount: isBgTaskEvent,
+				perTaskEntry: isBgTaskEvent && suspTaskId ? {
+					toolCallId: suspToolCallId,
+					suspendedAt: suspSuspendedAt,
+					taskId: suspTaskId
+				} : void 0
+			}, { suspendedTools: {
+				...lastSuspendedTools,
+				[suspToolName]: {
+					toolCallId: suspToolCallId,
+					toolName: suspToolName,
+					args: suspArgs,
+					suspendPayload: suspPayload,
+					runId: chunk.runId
+				}
+			} });
+			return replaceAt(result, messageIndex, withMetadata(targetMessage, nextMetadata));
+		}
+		case "tool-call-resumed": {
+			const resumedToolCallId = chunk.payload.toolCallId;
+			for (let i = result.length - 1; i >= 0; i--) {
+				const message = result[i];
+				if (!message || message.role !== "assistant") continue;
+				const meta = message.content.metadata;
+				const metadataKeys = chunk.payload.kind === "approval" ? ["pendingToolApprovals", "requireApprovalMetadata"] : ["suspendedTools"];
+				let nextMeta;
+				for (const metadataKey of metadataKeys) {
+					const entries = meta?.[metadataKey];
+					if (!entries) continue;
+					const key = Object.keys(entries).find((k) => (entries[k]?.toolCallId ?? k) === resumedToolCallId);
+					if (!key) continue;
+					const { [key]: _removed, ...remaining } = entries;
+					nextMeta = {
+						...nextMeta ?? meta,
+						[metadataKey]: remaining
+					};
+				}
+				if (nextMeta) return replaceAt(result, i, withMetadata(message, nextMeta));
+			}
+			return result;
+		}
+		case "finish":
+		case "abort": return finishStreamingAssistantMessage(result);
+		case "error": {
+			const newMessage = newAssistantMessage(`error-${chunk.runId + Date.now()}`, [{
+				type: "text",
+				text: typeof chunk.payload.error === "string" ? chunk.payload.error : JSON.stringify(chunk.payload.error)
+			}], {
+				...metadata,
+				status: "error"
+			});
+			return [...result, newMessage];
+		}
+		case "step-start": {
+			const stepMessageId = typeof chunk.payload?.messageId === "string" ? chunk.payload.messageId : void 0;
+			if (!stepMessageId) return result;
+			const lastMessage = result[result.length - 1];
+			if (result.some((message) => message.id === stepMessageId)) return result;
+			if (!lastMessage || lastMessage.role !== "assistant") return appendAssistantMessage(result, stepMessageId, [], metadata);
+			if (!lastMessage.content.parts.some((part) => !String(part.type).startsWith("data-"))) return replaceLast(result, {
+				...lastMessage,
+				id: stepMessageId
+			});
+			return appendAssistantMessage(finishStreamingAssistantMessage(result), stepMessageId, [], metadata);
+		}
+		case "step-finish":
+		case "step-output":
+		case "raw":
+		case "watch":
+		case "response-metadata": return result;
+		case "goal": return result;
+		case "object":
+		case "object-result": return result;
+		case "background-task-started":
+		case "background-task-cancelled":
+		case "background-task-resumed": return result;
+		case "workflow-start":
+		case "workflow-finish":
+		case "workflow-canceled":
+		case "workflow-paused":
+		case "workflow-step-start":
+		case "workflow-step-finish":
+		case "workflow-step-suspended":
+		case "workflow-step-waiting":
+		case "workflow-step-output":
+		case "workflow-step-progress":
+		case "workflow-step-result": return result;
+		case "agent-execution-start":
+		case "agent-execution-approval":
+		case "agent-execution-suspended":
+		case "agent-execution-end":
+		case "agent-execution-abort":
+		case "tool-execution-start":
+		case "tool-execution-end":
+		case "tool-execution-approval":
+		case "tool-execution-suspended":
+		case "tool-execution-abort":
+		case "routing-agent-start":
+		case "routing-agent-text-delta":
+		case "routing-agent-text-start":
+		case "routing-agent-end":
+		case "routing-agent-abort":
+		case "workflow-execution-start":
+		case "workflow-execution-end":
+		case "workflow-execution-suspended":
+		case "workflow-execution-abort":
+		case "network-execution-event-step-finish":
+		case "network-execution-event-finish":
+		case "network-validation-start":
+		case "network-validation-end":
+		case "network-object":
+		case "network-object-result": return result;
+		default: return assertExhaustive(chunk, result);
+	}
+};
+/**
+* Compile-time exhaustiveness helper. At runtime, returns the conversation
+* unchanged so unexpected chunk variants never throw inside the React stream
+* pump; TypeScript will fail to compile if `ChunkType` ever grows a new branch
+* that isn't enumerated above.
+*/
+const assertExhaustive = (_chunk, fallback) => fallback;
+const findAgentChildToolIndex = (childMessages, toolCallId, toolName) => {
+	for (let index = childMessages.length - 1; index >= 0; index--) {
+		const message = childMessages[index];
+		if (message?.type !== "tool") continue;
+		if (toolCallId ? message.toolCallId === toolCallId : toolName && message.toolName === toolName) return index;
+	}
+	return -1;
+};
+const accumulateAgentChildMessages = (chunk, childMessages) => {
+	if (chunk.type === "text-delta") {
+		const text = chunk.payload.text;
+		const lastChildMessage = childMessages[childMessages.length - 1];
+		const textMessage = {
+			type: "text",
+			content: (lastChildMessage?.type === "text" ? lastChildMessage.content : "") + text
+		};
+		return lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+	}
+	if (chunk.type === "tool-call") {
+		const existingIndex = findAgentChildToolIndex(childMessages, chunk.payload.toolCallId);
+		const toolMessage = {
+			...existingIndex === -1 ? {} : childMessages[existingIndex],
+			type: "tool",
+			toolCallId: chunk.payload.toolCallId,
+			toolName: chunk.payload.toolName,
+			args: chunk.payload.args
+		};
+		if (existingIndex === -1) return [...childMessages, toolMessage];
+		const nextMessages = [...childMessages];
+		nextMessages[existingIndex] = toolMessage;
+		return nextMessages;
+	}
+	if (chunk.type === "tool-output" && chunk.payload.output?.type?.startsWith("workflow-")) {
+		const toolIndex = findAgentChildToolIndex(childMessages, chunk.payload.toolCallId, chunk.payload.toolName);
+		if (toolIndex === -1) return childMessages;
+		const currentMessage = childMessages[toolIndex];
+		if (currentMessage?.type !== "tool") return childMessages;
+		const existingWorkflowState = currentMessage.toolOutput && typeof currentMessage.toolOutput === "object" ? currentMessage.toolOutput : {};
+		const updated = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload.output);
+		const nextMessages = [...childMessages];
+		nextMessages[toolIndex] = {
+			...currentMessage,
+			toolOutput: {
+				...updated,
+				runId: chunk.payload.output.runId
+			}
+		};
+		return nextMessages;
+	}
+	if (chunk.type === "tool-result") {
+		const toolIndex = findAgentChildToolIndex(childMessages, chunk.payload.toolCallId, chunk.payload.toolName);
+		if (toolIndex === -1) return childMessages;
+		const currentMessage = childMessages[toolIndex];
+		if (currentMessage?.type !== "tool") return childMessages;
+		const result = chunk.payload.result;
+		const nextMessages = [...childMessages];
+		nextMessages[toolIndex] = {
+			...currentMessage,
+			toolOutput: chunk.payload.toolName?.startsWith("workflow-") ? {
+				...result?.result ?? {},
+				runId: result?.runId
+			} : chunk.payload.result
+		};
+		return nextMessages;
+	}
+	return childMessages;
+};
+const routeAgentChunk = (chunk, childMessages, boundaries) => {
+	const [boundary, ...remaining] = boundaries;
+	if (!boundary) return accumulateAgentChildMessages(chunk, childMessages);
+	let toolIndex = findAgentChildToolIndex(childMessages, boundary.toolCallId, boundary.toolName);
+	let nextMessages = childMessages;
+	if (toolIndex === -1) {
+		toolIndex = childMessages.length;
+		nextMessages = [...childMessages, {
+			type: "tool",
+			toolCallId: boundary.toolCallId,
+			toolName: boundary.toolName,
+			args: {}
+		}];
+	}
+	const currentMessage = nextMessages[toolIndex];
+	if (currentMessage?.type !== "tool" || !currentMessage.toolName.startsWith("agent-")) return childMessages;
+	const currentOutput = currentMessage.toolOutput !== null && typeof currentMessage.toolOutput === "object" ? currentMessage.toolOutput : {};
+	const nestedMessages = Array.isArray(currentOutput.childMessages) ? currentOutput.childMessages : [];
+	const updatedNestedMessages = routeAgentChunk(chunk, nestedMessages, remaining);
+	if (updatedNestedMessages === nestedMessages) return childMessages;
+	const updatedMessages = [...nextMessages];
+	updatedMessages[toolIndex] = {
+		...currentMessage,
+		toolOutput: {
+			...currentOutput,
+			childMessages: updatedNestedMessages
+		}
+	};
+	return updatedMessages;
+};
+const accumulateAgentChunk = (chunk, conversation, _metadata, parentToolCallId, parentToolName, boundaries = []) => {
+	if (!parentToolCallId) return conversation;
+	const location = locateToolPart(conversation, parentToolCallId, false);
+	if (!location) return conversation;
+	const targetMessage = conversation[location.messageIndex];
+	if (!targetMessage || targetMessage.role !== "assistant") return conversation;
+	const parts = [...targetMessage.content.parts];
+	const toolPart = parts[location.toolPartIndex];
+	if (!toolPart || !isToolPart(toolPart)) return conversation;
+	if (parentToolName && toolPart.toolInvocation.toolName !== parentToolName) return conversation;
+	const invocationResult = "result" in toolPart.toolInvocation && toolPart.toolInvocation.result !== null ? toolPart.toolInvocation.result : void 0;
+	const existingResult = invocationResult && typeof invocationResult === "object" ? invocationResult : {};
+	const childMessages = Array.isArray(existingResult.childMessages) ? existingResult.childMessages : [];
+	const updatedChildMessages = routeAgentChunk(chunk, childMessages, boundaries);
+	if (updatedChildMessages === childMessages) return conversation;
+	parts[location.toolPartIndex] = {
+		...toolPart,
+		toolInvocation: {
+			...toolPart.toolInvocation,
+			state: "partial-call",
+			result: {
+				...existingResult,
+				childMessages: updatedChildMessages
+			}
+		}
+	};
+	return replaceAt(conversation, location.messageIndex, withParts(targetMessage, parts));
+};
+const networkMode = (metadata) => ({
+	...metadata,
+	mode: "network"
+});
+const findPartIndex = (parts, predicate) => parts.findIndex(predicate);
+const isDynamicToolPart = (part) => part.type === "dynamic-tool";
+const lastAssistant = (conversation) => {
+	const last = conversation[conversation.length - 1];
+	return last && last.role === "assistant" ? last : void 0;
+};
+/**
+* Try to parse the buffered routing-agent text as a JSON object. Returns the
+* parsed object on success, or `null` while the buffer is still incomplete or
+* not JSON at all.
+*/
+const tryParseRoutingDecision = (buffered) => {
+	const trimmed = buffered.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (parsed && typeof parsed === "object") return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Routing-agent text deltas describe the network's routing decision (often a
+* JSON object such as `{ "isNetwork": true, "agentId": "...", ... }`). The raw
+* payload is never useful in the rendered thread, so we buffer it in
+* message-level metadata, promote it to `routingDecision` when it parses as
+* JSON, and fall back to `routingDecisionText` for non-JSON routing models.
+* No visible text part is produced.
+*/
+const handleRoutingAgentDelta = (chunk, conversation, metadata) => {
+	const delta = chunk.payload?.text ?? "";
+	if (!delta) return conversation;
+	const lastMessage = lastAssistant(conversation);
+	const mergeRoutingMetadata = (existing) => {
+		const buffered = (existing.routingDecisionBuffer ?? "") + delta;
+		const next = {
+			...cloneMetadata(existing),
+			mode: "network"
+		};
+		const parsed = tryParseRoutingDecision(buffered);
+		if (parsed) {
+			next.routingDecision = parsed;
+			delete next.routingDecisionBuffer;
+			delete next.routingDecisionText;
+		} else {
+			next.routingDecisionBuffer = buffered;
+			next.routingDecisionText = buffered;
+		}
+		return next;
+	};
+	if (!lastMessage) {
+		const seed = mergeRoutingMetadata({});
+		return appendAssistantMessage(conversation, `routing-agent-${chunk.payload?.runId ?? "unknown"}-${Date.now()}`, [], {
+			...networkMode(metadata),
+			...seed
+		});
+	}
+	return replaceLast(conversation, withMetadata(lastMessage, mergeRoutingMetadata(lastMessage.content.metadata ?? {})));
+};
+const handleAgentNetworkChunk = (chunk, conversation, metadata) => {
+	if (chunk.type === "agent-execution-start") {
+		const primitiveId = chunk.payload?.args?.primitiveId;
+		const runId = chunk.payload.runId;
+		if (!primitiveId || !runId) return conversation;
+		const toolPart = {
+			type: "dynamic-tool",
+			toolName: primitiveId,
+			toolCallId: runId,
+			state: "input-available",
+			input: chunk.payload.args
+		};
+		return appendAssistantMessage(conversation, `agent-execution-start-${runId}-${Date.now()}`, [toolPart], {
+			...networkMode(metadata),
+			selectionReason: chunk.payload?.args?.selectionReason || "",
+			agentInput: chunk.payload?.args?.task,
+			from: "AGENT"
+		});
+	}
+	if (chunk.type === "agent-execution-end") {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const parts = [...lastMessage.content.parts];
+		const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+		if (toolPartIndex !== -1) {
+			const toolPart = parts[toolPartIndex];
+			const currentOutput = toolPart.output;
+			parts[toolPartIndex] = {
+				type: "dynamic-tool",
+				toolName: toolPart.toolName,
+				toolCallId: toolPart.toolCallId,
+				state: "output-available",
+				input: toolPart.input,
+				output: {
+					...currentOutput,
+					result: currentOutput?.result || chunk.payload?.result || ""
+				}
+			};
+		}
+		return replaceLast(conversation, withParts(lastMessage, parts));
+	}
+	if (chunk.type.startsWith("agent-execution-event-")) {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const agentChunk = chunk.payload;
+		const parts = [...lastMessage.content.parts];
+		const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+		if (toolPartIndex === -1) return conversation;
+		const toolPart = parts[toolPartIndex];
+		if (agentChunk.type === "text-delta") {
+			const childMessages = toolPart?.output?.childMessages || [];
+			const lastChildMessage = childMessages[childMessages.length - 1];
+			const textMessage = {
+				type: "text",
+				content: (lastChildMessage?.content || "") + agentChunk.payload.text
+			};
+			const nextMessages = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+			parts[toolPartIndex] = {
+				...toolPart,
+				output: { childMessages: nextMessages }
+			};
+		} else if (agentChunk.type === "tool-call") {
+			const childMessages = toolPart?.output?.childMessages || [];
+			parts[toolPartIndex] = {
+				...toolPart,
+				output: {
+					...toolPart?.output,
+					childMessages: [...childMessages, {
+						type: "tool",
+						toolCallId: agentChunk.payload.toolCallId,
+						toolName: agentChunk.payload.toolName,
+						args: agentChunk.payload.args
+					}]
+				}
+			};
+		} else if (agentChunk.type === "tool-output") {
+			if (agentChunk.payload?.output?.type?.startsWith("workflow-")) {
+				const childMessages = toolPart?.output?.childMessages || [];
+				const lastToolIndex = childMessages.length - 1;
+				const currentMessage = childMessages[lastToolIndex];
+				const actualExistingWorkflowState = currentMessage?.toolOutput || {};
+				const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(actualExistingWorkflowState, agentChunk.payload.output);
+				if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") parts[toolPartIndex] = {
+					...toolPart,
+					output: {
+						...toolPart?.output,
+						childMessages: [...childMessages.slice(0, -1), {
+							...currentMessage,
+							toolOutput: updatedWorkflowState
+						}]
+					}
+				};
+			}
+		} else if (agentChunk.type === "tool-result") {
+			const childMessages = toolPart?.output?.childMessages || [];
+			const lastToolIndex = childMessages.length - 1;
+			const isWorkflow = Boolean(agentChunk.payload?.result?.result?.steps);
+			if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") parts[toolPartIndex] = {
+				...toolPart,
+				output: {
+					...toolPart?.output,
+					childMessages: [...childMessages.slice(0, -1), {
+						...childMessages[lastToolIndex],
+						toolOutput: isWorkflow ? agentChunk.payload.result.result : agentChunk.payload.result
+					}]
+				}
+			};
+		}
+		return replaceLast(conversation, withParts(lastMessage, parts));
+	}
+	return conversation;
+};
+const handleWorkflowNetworkChunk = (chunk, conversation, metadata) => {
+	if (chunk.type === "workflow-execution-start") {
+		const primitiveId = chunk.payload?.args?.primitiveId;
+		const runId = chunk.payload.runId;
+		if (!primitiveId || !runId) return conversation;
+		let agentInput;
+		try {
+			agentInput = JSON.parse(chunk.payload?.args?.prompt);
+		} catch {
+			agentInput = chunk.payload?.args?.prompt;
+		}
+		const toolPart = {
+			type: "dynamic-tool",
+			toolName: primitiveId,
+			toolCallId: runId,
+			state: "input-available",
+			input: chunk.payload.args
+		};
+		return appendAssistantMessage(conversation, `workflow-start-${runId}-${Date.now()}`, [toolPart], {
+			...networkMode(metadata),
+			selectionReason: chunk.payload?.args?.selectionReason || "",
+			from: "WORKFLOW",
+			agentInput
+		});
+	}
+	if (chunk.type === "workflow-execution-suspended") {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const existing = lastMessage.content.metadata?.suspendedTools ?? {};
+		return replaceLast(conversation, withMetadata(lastMessage, {
+			...cloneMetadata(lastMessage.content.metadata),
+			mode: "network",
+			suspendedTools: {
+				...existing,
+				[chunk.payload.toolName]: {
+					toolCallId: chunk.payload.toolCallId,
+					toolName: chunk.payload.toolName,
+					args: chunk.payload.args,
+					suspendPayload: chunk.payload.suspendPayload,
+					runId: chunk.payload.runId
+				}
+			}
+		}));
+	}
+	if (chunk.type.startsWith("workflow-execution-event-")) {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const parts = [...lastMessage.content.parts];
+		const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+		if (toolPartIndex === -1) return conversation;
+		const toolPart = parts[toolPartIndex];
+		const existingWorkflowState = toolPart.output || {};
+		const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload);
+		parts[toolPartIndex] = {
+			...toolPart,
+			output: updatedWorkflowState
+		};
+		return replaceLast(conversation, withParts(lastMessage, parts));
+	}
+	return conversation;
+};
+const handleToolNetworkChunk = (chunk, conversation, metadata) => {
+	if (chunk.type === "tool-execution-start") {
+		const argsData = chunk.payload.args;
+		const nestedArgs = argsData.args || {};
+		const lastMessage = lastAssistant(conversation);
+		const toolPart = {
+			type: "dynamic-tool",
+			toolName: argsData.toolName || "unknown",
+			toolCallId: argsData.toolCallId || "unknown",
+			state: "input-available",
+			input: nestedArgs
+		};
+		if (!lastMessage) return appendAssistantMessage(conversation, `tool-start-${chunk.payload.runId}-${Date.now()}`, [toolPart], {
+			...networkMode(metadata),
+			selectionReason: metadata.mode === "network" ? metadata.selectionReason || argsData.selectionReason : "",
+			agentInput: nestedArgs
+		});
+		const parts = [...lastMessage.content.parts, toolPart];
+		return replaceLast(conversation, withParts(lastMessage, parts));
+	}
+	if (chunk.type === "tool-execution-approval") {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const existing = lastMessage.content.metadata?.requireApprovalMetadata ?? {};
+		return replaceLast(conversation, withMetadata(lastMessage, {
+			...cloneMetadata(lastMessage.content.metadata),
+			mode: "network",
+			requireApprovalMetadata: {
+				...existing,
+				[chunk.payload.toolName]: {
+					toolCallId: chunk.payload.toolCallId,
+					toolName: chunk.payload.toolName,
+					args: chunk.payload.args,
+					runId: chunk.payload.runId
+				}
+			}
+		}));
+	}
+	if (chunk.type === "tool-execution-suspended") {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const existing = lastMessage.content.metadata?.suspendedTools ?? {};
+		return replaceLast(conversation, withMetadata(lastMessage, {
+			...cloneMetadata(lastMessage.content.metadata),
+			mode: "network",
+			suspendedTools: {
+				...existing,
+				[chunk.payload.toolName]: {
+					toolCallId: chunk.payload.toolCallId,
+					toolName: chunk.payload.toolName,
+					args: chunk.payload.args,
+					suspendPayload: chunk.payload.suspendPayload,
+					runId: chunk.payload.runId
+				}
+			}
+		}));
+	}
+	if (chunk.type === "tool-execution-end") {
+		const lastMessage = lastAssistant(conversation);
+		if (!lastMessage) return conversation;
+		const parts = [...lastMessage.content.parts];
+		const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part) && part.toolCallId === chunk.payload.toolCallId);
+		if (toolPartIndex !== -1) {
+			const toolPart = parts[toolPartIndex];
+			const currentOutput = toolPart.output;
+			parts[toolPartIndex] = {
+				type: "dynamic-tool",
+				toolName: toolPart.toolName,
+				toolCallId: toolPart.toolCallId,
+				state: "output-available",
+				input: toolPart.input,
+				output: currentOutput?.result || chunk.payload?.result || ""
+			};
+		}
+		return replaceLast(conversation, withParts(lastMessage, parts));
+	}
+	return conversation;
+};
+/**
+* Reduce a single network-mode chunk into the running `MastraDBMessage[]`
+* conversation. Ports the historical `AISdkNetworkTransformer` so the playground
+* keeps rendering network badges (routing text, agent/workflow/tool execution,
+* suspensions, approvals, completion feedback) until the next major.
+*/
+const accumulateNetworkChunk = ({ chunk, conversation, metadata }) => {
+	const newConversation = [...conversation];
+	if (chunk.type === "routing-agent-text-delta") return handleRoutingAgentDelta(chunk, newConversation, metadata);
+	if (chunk.type.startsWith("agent-execution-")) return handleAgentNetworkChunk(chunk, newConversation, metadata);
+	if (chunk.type.startsWith("workflow-execution-")) return handleWorkflowNetworkChunk(chunk, newConversation, metadata);
+	if (chunk.type.startsWith("tool-execution-")) return handleToolNetworkChunk(chunk, newConversation, metadata);
+	if (chunk.type === "network-validation-end") {
+		if (chunk.payload.suppressFeedback) return newConversation;
+		const textPart = {
+			type: "text",
+			text: formatCompletionFeedback({
+				complete: chunk.payload.passed,
+				scorers: chunk.payload.results,
+				totalDuration: chunk.payload.duration,
+				timedOut: chunk.payload.timedOut,
+				completionReason: chunk.payload.reason
+			}, chunk.payload.maxIterationReached)
+		};
+		return appendAssistantMessage(newConversation, `network-validation-end-${chunk.payload.runId}-${Date.now()}`, [textPart], {
+			...networkMode(metadata),
+			completionResult: { passed: chunk.payload.passed }
+		});
+	}
+	if (chunk.type === "network-execution-event-step-finish") {
+		const lastMessage = lastAssistant(newConversation);
+		if (!lastMessage) return newConversation;
+		const agentChunk = chunk.payload;
+		const parts = [...lastMessage.content.parts];
+		const textPartIndex = findPartIndex(parts, (part) => part.type === "text");
+		if (textPartIndex === -1) {
+			parts.push({
+				type: "text",
+				text: agentChunk.result,
+				state: "done"
+			});
+			return replaceLast(newConversation, withParts(lastMessage, parts));
+		}
+		const textPart = parts[textPartIndex];
+		if (textPart.type === "text") {
+			parts[textPartIndex] = {
+				...textPart,
+				state: "done"
+			};
+			return replaceLast(newConversation, withParts(lastMessage, parts));
+		}
+		return newConversation;
+	}
+	return newConversation;
+};
+Object.defineProperty(exports, "CLIENT_MESSAGE_ID_KEY", {
+	enumerable: true,
+	get: function() {
+		return CLIENT_MESSAGE_ID_KEY;
+	}
+});
+Object.defineProperty(exports, "accumulateChunk", {
+	enumerable: true,
+	get: function() {
+		return accumulateChunk;
+	}
+});
+Object.defineProperty(exports, "accumulateNetworkChunk", {
+	enumerable: true,
+	get: function() {
+		return accumulateNetworkChunk;
+	}
+});
+Object.defineProperty(exports, "convertSignalDataToBase64String", {
+	enumerable: true,
+	get: function() {
+		return convertSignalDataToBase64String;
+	}
+});
+Object.defineProperty(exports, "encodeFilePartDataForStorage", {
+	enumerable: true,
+	get: function() {
+		return encodeFilePartDataForStorage;
+	}
+});
+Object.defineProperty(exports, "finishStreamingAssistantMessage", {
+	enumerable: true,
+	get: function() {
+		return finishStreamingAssistantMessage;
+	}
+});
+Object.defineProperty(exports, "mapWorkflowStreamChunkToWatchResult", {
+	enumerable: true,
+	get: function() {
+		return mapWorkflowStreamChunkToWatchResult;
+	}
+});
+
+//# sourceMappingURL=accumulator-Bjfckb5t.cjs.map