@mastra/react 1.5.1-alpha.2 → 1.6.0-alpha.10

package/dist/index.js

@@ -1,4 +1,3 @@
-import { $ as useEntity, A as TooltipContentClass, B as ToolApprovalContent, C as CodeBlock, D as IconButtonClass, E as IconButton, F as EntryTitleClass, G as ToolApprovalTitleClass, H as ToolApprovalHeader, I as ToolApproval, J as EntityContent, K as Entity, L as ToolApprovalActions, M as Entry, N as EntryClass, O as Tooltip, P as EntryTitle, Q as EntityTriggerVariantClasses, R as ToolApprovalActionsClass, S as AgentIcon, T as CodeCopyButton, U as ToolApprovalHeaderClass, V as ToolApprovalContentClass, W as ToolApprovalTitle, X as EntityTrigger, Y as EntityContentClass, Z as EntityTriggerClass, _ as MessageUsageValueClass, a as MessageClass, b as WorkflowIcon, c as MessageList, d as MessageStreamingClass, et as Icon, f as MessageUsage, g as MessageUsageValue, h as MessageUsageEntryClass, i as MessageActionsClass, j as TooltipTrigger, k as TooltipContent, l as MessageListClass, m as MessageUsageEntry, n as Message, o as MessageContent, p as MessageUsageClass, q as EntityCaret, r as MessageActions, s as MessageContentClass, t as MessageFactory, tt as IconSizes, u as MessageStreaming, v as MessageUsages, w as CodeBlockClass, x as ToolsIcon, y as MessageUsagesClass, z as ToolApprovalClass } from "./ui-BQyoxYsH.js";
 import { MastraClient } from "@mastra/client-js";
 import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
@@ -140,6 +139,37 @@ function toolErrorText(error) {
 	}
 	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,
@@ -267,39 +297,47 @@ const mergeBgTaskMetadata = (existing, mode, args, otherMetadata) => {
 * `mapWorkflowStreamChunkToWatchResult` from the previous accumulator.
 */
 const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+	const previous = prev ?? {
+		status: "running",
+		input: void 0,
+		steps: {}
+	};
 	if (chunk.type === "workflow-start") return {
-		input: prev?.input,
+		input: previous.input,
 		status: "running",
-		steps: prev?.steps || {}
+		steps: previous.steps
 	};
 	if (chunk.type === "workflow-canceled") return {
-		...prev,
+		...previous,
 		status: "canceled"
 	};
+	if (chunk.type === "workflow-paused") return {
+		...previous,
+		status: "paused"
+	};
 	if (chunk.type === "workflow-finish") {
 		const finalStatus = chunk.payload.workflowStatus;
-		const prevSteps = prev?.steps ?? {};
-		const lastStep = Object.values(prevSteps).pop();
+		const lastStep = Object.values(previous.steps).pop();
 		return {
-			...prev,
+			...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 { stepCallId: _stepCallId, stepName: _stepName, ...newPayload } = chunk.payload ?? {};
 	const newSteps = {
-		...prev?.steps,
+		...previous.steps,
 		[chunk.payload.id]: {
-			...prev?.steps?.[chunk.payload.id],
+			...previous.steps[chunk.payload.id],
 			...newPayload
 		}
 	};
 	if (chunk.type === "workflow-step-start") return {
-		...prev,
+		...previous,
 		steps: newSteps
 	};
 	if (chunk.type === "workflow-step-suspended") {
-		const suspendedStepIds = Object.entries(newSteps).flatMap(([stepId, stepResult]) => {
+		const suspended = Object.entries(newSteps).flatMap(([stepId, stepResult]) => {
 			if (stepResult?.status === "suspended") {
 				const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
 				return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
@@ -307,24 +345,24 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
 			return [];
 		});
 		return {
-			...prev,
+			...previous,
 			status: "suspended",
 			steps: newSteps,
 			suspendPayload: chunk.payload.suspendPayload,
-			suspended: suspendedStepIds
+			suspended
 		};
 	}
 	if (chunk.type === "workflow-step-waiting") return {
-		...prev,
+		...previous,
 		status: "waiting",
 		steps: newSteps
 	};
 	if (chunk.type === "workflow-step-progress") return {
-		...prev,
+		...previous,
 		steps: {
-			...prev?.steps,
+			...previous.steps,
 			[chunk.payload.id]: {
-				...prev?.steps?.[chunk.payload.id],
+				...previous.steps[chunk.payload.id],
 				foreachProgress: {
 					completedCount: chunk.payload.completedCount,
 					totalCount: chunk.payload.totalCount,
@@ -336,10 +374,10 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
 		}
 	};
 	if (chunk.type === "workflow-step-result") return {
-		...prev,
+		...previous,
 		steps: newSteps
 	};
-	return prev;
+	return previous;
 };
 const signalContentsToUserMessages = (contents, metadata) => {
 	const makeUserMessage = (parts) => ({
@@ -829,7 +867,7 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 							toolName,
 							args,
 							errorText,
-							...toolName?.startsWith("agent-") ? { result: toolPart.toolInvocation.result } : {}
+							...chunk.from === "AGENT" ? { result: toolPart.toolInvocation.result } : {}
 						}
 					};
 				} else {
@@ -851,7 +889,7 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 						};
 						else output = payloadResult;
 					} else if (isAgent) {
-						const existingOutput = toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
+						const existingOutput = toolPart.toolInvocation.state === "partial-call" || toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
 						const existingChild = existingOutput?.childMessages;
 						output = existingOutput ? {
 							...payloadResult,
@@ -916,7 +954,7 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 			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 existingWorkflowState = toolPart.toolInvocation.result;
 				const updated = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, payloadOutput);
 				parts[toolPartIndex] = {
 					...toolPart,
@@ -928,8 +966,13 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 						result: updated
 					}
 				};
-			} else if (payloadOutput?.from === "AGENT" || payloadOutput?.from === "USER" && payloadOutput?.payload?.output?.type?.startsWith("workflow-")) return accumulateAgentChunk(payloadOutput, result, metadata, toolCallId, toolName);
-			else {
+			} 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] = {
@@ -1146,8 +1189,7 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 		case "network-validation-start":
 		case "network-validation-end":
 		case "network-object":
-		case "network-object-result":
-		case "tool-output-denied": return result;
+		case "network-object-result": return result;
 		default: return assertExhaustive(chunk, result);
 	}
 };
@@ -1158,112 +1200,130 @@ const accumulateChunk = ({ chunk, conversation, metadata }) => {
 * that isn't enumerated above.
 */
 const assertExhaustive = (_chunk, fallback) => fallback;
-const accumulateAgentChunk = (chunk, conversation, _metadata, parentToolCallId, parentToolName) => {
-	const lastMessage = conversation[conversation.length - 1];
-	if (!lastMessage || lastMessage.role !== "assistant") return conversation;
-	const parts = [...lastMessage.content.parts];
-	const findToolPartIndex = () => parts.findIndex((part) => isToolPart(part) && (parentToolCallId && part.toolInvocation.toolCallId === parentToolCallId || parentToolName && part.toolInvocation.toolName === parentToolName));
+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 agentChunk = chunk.payload;
-		const toolPartIndex = findToolPartIndex();
-		if (toolPartIndex === -1) return conversation;
-		const toolPart = parts[toolPartIndex];
-		const existingResult = toolPart.toolInvocation.result || {};
-		const childMessages = existingResult.childMessages || [];
+		const text = chunk.payload.text;
 		const lastChildMessage = childMessages[childMessages.length - 1];
 		const textMessage = {
 			type: "text",
-			content: (lastChildMessage?.content || "") + agentChunk.text
+			content: (lastChildMessage?.type === "text" ? lastChildMessage.content : "") + text
 		};
-		const nextChildren = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
-		parts[toolPartIndex] = {
-			...toolPart,
-			toolInvocation: {
-				...toolPart.toolInvocation,
-				result: {
-					...existingResult,
-					childMessages: nextChildren
-				}
-			}
+		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
 		};
-	} else if (chunk.type === "tool-call") {
-		const agentChunk = chunk.payload;
-		const toolPartIndex = findToolPartIndex();
-		if (toolPartIndex === -1) return conversation;
-		const toolPart = parts[toolPartIndex];
-		const existingResult = toolPart.toolInvocation.result || {};
-		const childMessages = existingResult.childMessages || [];
-		parts[toolPartIndex] = {
-			...toolPart,
-			toolInvocation: {
-				...toolPart.toolInvocation,
-				result: {
-					...existingResult,
-					childMessages: [...childMessages, {
-						type: "tool",
-						toolCallId: agentChunk.toolCallId,
-						toolName: agentChunk.toolName,
-						args: agentChunk.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
 			}
 		};
-	} else if (chunk.type === "tool-output") {
-		const agentChunk = chunk.payload;
-		const toolPartIndex = findToolPartIndex();
-		if (toolPartIndex === -1) return conversation;
-		const toolPart = parts[toolPartIndex];
-		if (agentChunk?.output?.type?.startsWith("workflow-")) {
-			const existingResult = toolPart.toolInvocation.result || {};
-			const childMessages = existingResult.childMessages || [];
-			const lastIndex = childMessages.length - 1;
-			const currentMessage = childMessages[lastIndex];
-			const actualExistingWorkflowState = currentMessage?.toolOutput || {};
-			const updated = mapWorkflowStreamChunkToWatchResult(actualExistingWorkflowState, agentChunk.output);
-			if (lastIndex >= 0 && childMessages[lastIndex]?.type === "tool") parts[toolPartIndex] = {
-				...toolPart,
-				toolInvocation: {
-					...toolPart.toolInvocation,
-					result: {
-						...existingResult,
-						childMessages: [...childMessages.slice(0, -1), {
-							...currentMessage,
-							toolOutput: {
-								...updated,
-								runId: agentChunk.output.runId
-							}
-						}]
-					}
-				}
-			};
-		}
-	} else if (chunk.type === "tool-result") {
-		const agentChunk = chunk.payload;
-		const toolPartIndex = findToolPartIndex();
-		if (toolPartIndex === -1) return conversation;
-		const toolPart = parts[toolPartIndex];
-		const existingResult = toolPart.toolInvocation.result || {};
-		const childMessages = existingResult.childMessages || [];
-		const lastIndex = childMessages.length - 1;
-		const isWorkflow = agentChunk?.toolName?.startsWith("workflow-");
-		if (lastIndex >= 0 && childMessages[lastIndex]?.type === "tool") parts[toolPartIndex] = {
-			...toolPart,
-			toolInvocation: {
-				...toolPart.toolInvocation,
-				result: {
-					...existingResult,
-					childMessages: [...childMessages.slice(0, -1), {
-						...childMessages[lastIndex],
-						toolOutput: isWorkflow ? {
-							...agentChunk.result?.result,
-							runId: agentChunk.result?.runId
-						} : agentChunk.result
-					}]
-				}
-			}
+		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 replaceLast(conversation, withParts(lastMessage, parts));
+	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,
@@ -2816,275 +2876,133 @@ function useMutation(mutationFn) {
 }
 //#endregion
 //#region src/workflows/use-stream-workflow.ts
-/**
-* Hook for streaming workflow execution with support for observing, resuming, and time-travel.
-*
-* @example
-* ```tsx
-* const {
-*   streamWorkflow,
-*   streamResult,
-*   isStreaming,
-*   observeWorkflowStream,
-*   closeStreamsAndReset,
-*   resumeWorkflowStream,
-*   timeTravelWorkflowStream,
-* } = useStreamWorkflow({
-*   debugMode: true,
-*   tracingOptions: { enabled: true },
-*   onError: (error, defaultMessage) => console.error(defaultMessage, error),
-* });
-*
-* // Start streaming a workflow
-* await streamWorkflow.mutateAsync({
-*   workflowId: 'my-workflow',
-*   runId: 'run-123',
-*   inputData: { key: 'value' },
-*   requestContext: {},
-* });
-* ```
-*/
 function useStreamWorkflow({ debugMode, tracingOptions, onError }) {
 	const client = useMastraClient();
-	const [streamResult, setStreamResult] = useState({});
+	const [streamResult, setStreamResult] = useState();
 	const [isStreaming, setIsStreaming] = useState(false);
-	const readerRef = useRef(null);
-	const observerRef = useRef(null);
-	const resumeStreamRef = useRef(null);
-	const timeTravelStreamRef = useRef(null);
+	const activeStream = useRef(void 0);
 	const isMountedRef = useRef(true);
+	const closeActiveStream = useCallback(() => {
+		const operation = activeStream.current;
+		activeStream.current = void 0;
+		if (!operation) return;
+		operation.controller.abort();
+		operation.reader?.cancel().catch(() => void 0);
+		operation.reader?.releaseLock();
+		operation.reader = void 0;
+	}, []);
 	useEffect(() => {
 		isMountedRef.current = true;
 		return () => {
 			isMountedRef.current = false;
-			if (readerRef.current) {
-				try {
-					readerRef.current.releaseLock();
-				} catch {}
-				readerRef.current = null;
-			}
-			if (observerRef.current) {
-				try {
-					observerRef.current.releaseLock();
-				} catch {}
-				observerRef.current = null;
-			}
-			if (resumeStreamRef.current) {
-				try {
-					resumeStreamRef.current.releaseLock();
-				} catch {}
-				resumeStreamRef.current = null;
-			}
-			if (timeTravelStreamRef.current) {
-				try {
-					timeTravelStreamRef.current.releaseLock();
-				} catch {}
-				timeTravelStreamRef.current = null;
-			}
+			closeActiveStream();
 		};
-	}, []);
-	const handleStreamError = useCallback((err, defaultMessage, setStreamingState) => {
-		if (err instanceof TypeError) return;
-		const error = err instanceof Error ? err : new Error(defaultMessage);
-		onError?.(error, defaultMessage);
-		setStreamingState?.(false);
-	}, [onError]);
-	const handleWorkflowFinish = useCallback((value) => {
-		if (value.type === "workflow-finish") {
-			const streamStatus = value.payload?.workflowStatus;
-			const metadata = value.payload?.metadata;
-			setStreamResult((prev) => ({
-				...prev,
-				status: streamStatus
-			}));
-			if (streamStatus === "failed") throw new Error(metadata?.errorMessage || "Workflow execution failed");
-		}
-	}, []);
-	const streamWorkflow = useMutation(async ({ workflowId, runId, inputData, initialState, requestContext: playgroundRequestContext, perStep }) => {
-		if (readerRef.current) readerRef.current.releaseLock();
+	}, [closeActiveStream]);
+	async function consumeStream(openStream, defaultMessage) {
 		if (!isMountedRef.current) return;
+		closeActiveStream();
+		const operation = { controller: new AbortController() };
+		activeStream.current = operation;
+		const { signal } = operation.controller;
 		setIsStreaming(true);
-		setStreamResult({ input: inputData });
-		const stream = await (await client.getWorkflow(workflowId).createRun({ runId })).stream({
-			inputData,
-			initialState,
-			requestContext: playgroundRequestContext,
-			closeOnSuspend: true,
-			tracingOptions,
-			perStep: perStep ?? debugMode
-		});
-		if (!stream) return handleStreamError(/* @__PURE__ */ new Error("No stream returned"), "No stream returned", setIsStreaming);
-		const reader = stream.getReader();
-		readerRef.current = reader;
 		try {
-			while (true) {
-				if (!isMountedRef.current) break;
+			const stream = await openStream(signal);
+			if (signal.aborted) {
+				await stream?.cancel();
+				return;
+			}
+			if (!stream) {
+				onError?.(/* @__PURE__ */ new Error("No stream returned"), "No stream returned");
+				return;
+			}
+			const reader = stream.getReader();
+			operation.reader = reader;
+			while (!signal.aborted) {
 				const { done, value } = await reader.read();
-				if (done) break;
-				if (isMountedRef.current) {
-					setStreamResult((prev) => {
-						return mapWorkflowStreamChunkToWatchResult(prev, value);
-					});
-					if (value.type === "workflow-step-start") setIsStreaming(true);
-					if (value.type === "workflow-step-suspended") setIsStreaming(false);
-					if (value.type === "workflow-finish") handleWorkflowFinish(value);
-				}
+				if (done || signal.aborted) break;
+				setStreamResult((previous) => mapWorkflowStreamChunkToWatchResult(previous, value));
+				if (value.type === "workflow-step-start") setIsStreaming(true);
+				if (value.type === "workflow-step-suspended") setIsStreaming(false);
+				if (value.type === "workflow-finish" && value.payload.workflowStatus === "failed") throw new Error(value.payload.metadata?.errorMessage || "Workflow execution failed");
+			}
+		} catch (error) {
+			if (!signal.aborted) {
+				if (!operation.reader) throw error;
+				onError?.(error instanceof Error ? error : new Error(defaultMessage), defaultMessage);
 			}
-		} catch (err) {
-			handleStreamError(err, "Error streaming workflow");
 		} finally {
-			if (isMountedRef.current) setIsStreaming(false);
-			if (readerRef.current) {
-				readerRef.current.releaseLock();
-				readerRef.current = null;
+			operation.reader?.releaseLock();
+			operation.reader = void 0;
+			if (activeStream.current === operation) {
+				activeStream.current = void 0;
+				setIsStreaming(false);
 			}
 		}
+	}
+	const streamWorkflow = useMutation(({ workflowId, runId, inputData, initialState, requestContext, perStep }) => {
+		setStreamResult({
+			status: "pending",
+			input: inputData,
+			steps: {}
+		});
+		return consumeStream(async (signal) => {
+			const run = await client.getWorkflow(workflowId).createRun({ runId });
+			if (signal.aborted) return;
+			return run.stream({
+				inputData,
+				initialState,
+				requestContext,
+				closeOnSuspend: true,
+				tracingOptions,
+				perStep: perStep ?? debugMode
+			});
+		}, "Error streaming workflow");
 	});
 	const observeWorkflowStream = useMutation(async ({ workflowId, runId, storeRunResult }) => {
-		if (observerRef.current) observerRef.current.releaseLock();
 		if (!isMountedRef.current) return;
-		setIsStreaming(true);
-		setStreamResult(storeRunResult || {});
+		setStreamResult(storeRunResult ?? void 0);
 		if (storeRunResult?.status === "suspended") {
+			closeActiveStream();
 			setIsStreaming(false);
 			return;
 		}
-		const stream = await (await client.getWorkflow(workflowId).createRun({ runId })).observeStream();
-		if (!stream) return handleStreamError(/* @__PURE__ */ new Error("No stream returned"), "No stream returned", setIsStreaming);
-		const reader = stream.getReader();
-		observerRef.current = reader;
-		try {
-			while (true) {
-				if (!isMountedRef.current) break;
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (isMountedRef.current) {
-					setStreamResult((prev) => {
-						return mapWorkflowStreamChunkToWatchResult(prev, value);
-					});
-					if (value.type === "workflow-step-start") setIsStreaming(true);
-					if (value.type === "workflow-step-suspended") setIsStreaming(false);
-					if (value.type === "workflow-finish") handleWorkflowFinish(value);
-				}
-			}
-		} catch (err) {
-			handleStreamError(err, "Error observing workflow");
-		} finally {
-			if (isMountedRef.current) setIsStreaming(false);
-			if (observerRef.current) {
-				observerRef.current.releaseLock();
-				observerRef.current = null;
-			}
-		}
+		await consumeStream(async (signal) => {
+			const run = await client.getWorkflow(workflowId).createRun({ runId });
+			if (signal.aborted) return;
+			return run.observeStream();
+		}, "Error observing workflow");
 	});
-	const resumeWorkflowStream = useMutation(async ({ workflowId, runId, step, resumeData, requestContext: playgroundRequestContext, perStep }) => {
-		if (resumeStreamRef.current) resumeStreamRef.current.releaseLock();
-		if (!isMountedRef.current) return;
-		setIsStreaming(true);
-		const stream = await (await client.getWorkflow(workflowId).createRun({ runId })).resumeStream({
+	const resumeWorkflowStream = useMutation(({ workflowId, runId, step, resumeData, requestContext, perStep }) => consumeStream(async (signal) => {
+		const run = await client.getWorkflow(workflowId).createRun({ runId });
+		if (signal.aborted) return;
+		return run.resumeStream({
 			step,
 			resumeData,
-			requestContext: playgroundRequestContext,
+			requestContext,
 			tracingOptions,
 			perStep: perStep ?? debugMode
 		});
-		if (!stream) return handleStreamError(/* @__PURE__ */ new Error("No stream returned"), "No stream returned", setIsStreaming);
-		const reader = stream.getReader();
-		resumeStreamRef.current = reader;
-		try {
-			while (true) {
-				if (!isMountedRef.current) break;
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (isMountedRef.current) {
-					setStreamResult((prev) => {
-						return mapWorkflowStreamChunkToWatchResult(prev, value);
-					});
-					if (value.type === "workflow-step-start") setIsStreaming(true);
-					if (value.type === "workflow-step-suspended") setIsStreaming(false);
-					if (value.type === "workflow-finish") handleWorkflowFinish(value);
-				}
-			}
-		} catch (err) {
-			handleStreamError(err, "Error resuming workflow stream");
-		} finally {
-			if (isMountedRef.current) setIsStreaming(false);
-			if (resumeStreamRef.current) {
-				resumeStreamRef.current.releaseLock();
-				resumeStreamRef.current = null;
-			}
-		}
-	});
-	const timeTravelWorkflowStream = useMutation(async ({ workflowId, requestContext: playgroundRequestContext, runId, perStep, ...params }) => {
-		if (timeTravelStreamRef.current) timeTravelStreamRef.current.releaseLock();
-		if (!isMountedRef.current) return;
-		setIsStreaming(true);
-		const stream = await (await client.getWorkflow(workflowId).createRun({ runId })).timeTravelStream({
+	}, "Error resuming workflow stream"));
+	const timeTravelWorkflowStream = useMutation(({ workflowId, requestContext, runId, perStep, ...params }) => consumeStream(async (signal) => {
+		const run = await client.getWorkflow(workflowId).createRun({ runId });
+		if (signal.aborted) return;
+		return run.timeTravelStream({
 			...params,
 			perStep: perStep ?? debugMode,
-			requestContext: playgroundRequestContext,
+			requestContext,
 			tracingOptions
 		});
-		if (!stream) return handleStreamError(/* @__PURE__ */ new Error("No stream returned"), "No stream returned", setIsStreaming);
-		const reader = stream.getReader();
-		timeTravelStreamRef.current = reader;
-		try {
-			while (true) {
-				if (!isMountedRef.current) break;
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (isMountedRef.current) {
-					setStreamResult((prev) => {
-						return mapWorkflowStreamChunkToWatchResult(prev, value);
-					});
-					if (value.type === "workflow-step-start") setIsStreaming(true);
-					if (value.type === "workflow-step-suspended") setIsStreaming(false);
-					if (value.type === "workflow-finish") handleWorkflowFinish(value);
-				}
-			}
-		} catch (err) {
-			handleStreamError(err, "Error time traveling workflow stream");
-		} finally {
-			if (isMountedRef.current) setIsStreaming(false);
-			if (timeTravelStreamRef.current) {
-				timeTravelStreamRef.current.releaseLock();
-				timeTravelStreamRef.current = null;
-			}
-		}
-	});
+	}, "Error time traveling workflow stream"));
 	return {
 		streamWorkflow,
 		streamResult,
 		isStreaming,
 		observeWorkflowStream,
 		closeStreamsAndReset: useCallback(() => {
+			closeActiveStream();
 			setIsStreaming(false);
-			setStreamResult({});
-			if (readerRef.current) {
-				try {
-					readerRef.current.releaseLock();
-				} catch {}
-				readerRef.current = null;
-			}
-			if (observerRef.current) {
-				try {
-					observerRef.current.releaseLock();
-				} catch {}
-				observerRef.current = null;
-			}
-			if (resumeStreamRef.current) {
-				try {
-					resumeStreamRef.current.releaseLock();
-				} catch {}
-				resumeStreamRef.current = null;
-			}
-			if (timeTravelStreamRef.current) {
-				try {
-					timeTravelStreamRef.current.releaseLock();
-				} catch {}
-				timeTravelStreamRef.current = null;
-			}
-		}, []),
+			setStreamResult(void 0);
+		}, [closeActiveStream]),
 		resumeWorkflowStream,
 		timeTravelWorkflowStream
 	};
@@ -3421,6 +3339,6 @@ const useMastraSpeechToText = ({ agent, language }) => {
 	};
 };
 //#endregion
-export { AgentIcon, CLIENT_MESSAGE_ID_KEY, CodeBlock, CodeBlockClass, CodeCopyButton, Entity, EntityCaret, EntityContent, EntityContentClass, EntityTrigger, EntityTriggerClass, EntityTriggerVariantClasses, Entry, EntryClass, EntryTitle, EntryTitleClass, Icon, IconButton, IconButtonClass, IconSizes, MastraReactProvider, Message, MessageActions, MessageActionsClass, MessageClass, MessageContent, MessageContentClass, MessageFactory, MessageList, MessageListClass, MessageStreaming, MessageStreamingClass, MessageUsage, MessageUsageClass, MessageUsageEntry, MessageUsageEntryClass, MessageUsageValue, MessageUsageValueClass, MessageUsages, MessageUsagesClass, ToolApproval, ToolApprovalActions, ToolApprovalActionsClass, ToolApprovalClass, ToolApprovalContent, ToolApprovalContentClass, ToolApprovalHeader, ToolApprovalHeaderClass, ToolApprovalTitle, ToolApprovalTitleClass, ToolsIcon, Tooltip, TooltipContent, TooltipContentClass, TooltipTrigger, WorkflowIcon, WorkflowStepFactory, accumulateChunk, accumulateNetworkChunk, finishStreamingAssistantMessage, fromCoreUserMessageToMastraDBMessage, fromCoreUserMessagesToMastraDBMessage, mapWorkflowStreamChunkToWatchResult, playStreamWithWebAudio, recordMicrophoneToFile, useCancelWorkflowRun, useChat, useCreateWorkflowRun, useEntity, useMastraClient, useSpeechRecognition, useStreamWorkflow };
+export { CLIENT_MESSAGE_ID_KEY, MastraReactProvider, WorkflowStepFactory, accumulateChunk, accumulateNetworkChunk, finishStreamingAssistantMessage, fromCoreUserMessageToMastraDBMessage, fromCoreUserMessagesToMastraDBMessage, mapWorkflowStreamChunkToWatchResult, playStreamWithWebAudio, recordMicrophoneToFile, useCancelWorkflowRun, useChat, useCreateWorkflowRun, useMastraClient, useSpeechRecognition, useStreamWorkflow };
 
 //# sourceMappingURL=index.js.map