@mastra/react 1.5.1-alpha.3 → 1.6.0-alpha.4

package/dist/index.d.ts

@@ -6,7 +6,6 @@ export { useMastraClient } from './mastra-client-context.js';
 export * from './lib/mastra-db/index.js';
 export type { TaskItem } from '@mastra/core/signals';
 export type { MastraDBMessage, MastraMessageContentV2, MastraMessagePart, MastraToolApproval, MastraToolInvocation, MastraToolInvocationPart, MessageSource, MemoryInfo, } from '@mastra/core/agent/message-list';
-export * from './ui/index.js';
 export * from './workflows/index.js';
 export * from './voice/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAClG,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,aAAa,EACb,UAAU,GACX,MAAM,iCAAiC,CAAC;AACzC,cAAc,MAAM,CAAC;AACrB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAClG,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,cAAc,iBAAiB,CAAC;AAChC,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,aAAa,EACb,UAAU,GACX,MAAM,iCAAiC,CAAC;AACzC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

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";
@@ -267,39 +266,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 +314,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 +343,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) => ({
@@ -916,7 +923,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,
@@ -1146,8 +1153,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);
 	}
 };
@@ -2816,275 +2822,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 +3285,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