@mastra/react 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/index.js

@@ -1,1486 +1,3285 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { createContext, useContext, useState, Fragment, useLayoutEffect, useRef, useEffect } from 'react';
-import { MastraClient } from '@mastra/client-js';
-import { ChevronDownIcon, CheckIcon, CopyIcon } from 'lucide-react';
-import { twMerge } from 'tailwind-merge';
-import { toJsxRuntime } from 'hast-util-to-jsx-runtime';
-import { codeToHast } from 'shiki/bundle/web';
-import { TooltipProvider, Root, TooltipPortal, TooltipContent as TooltipContent$1, TooltipTrigger as TooltipTrigger$1 } from '@radix-ui/react-tooltip';
-
+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-Bd2cu1B9.js";
+import { MastraClient } from "@mastra/client-js";
+import { createContext, memo, useCallback, useContext, useEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+import { v4 } from "@lukeed/uuid";
+import { AIV5Adapter } from "@mastra/core/agent/message-list";
+//#region src/mastra-client-context.tsx
 const MastraClientContext = createContext({});
-const MastraClientProvider = ({ children, baseUrl, headers }) => {
-  const client = createMastraClient(baseUrl, headers);
-  return /* @__PURE__ */ jsx(MastraClientContext.Provider, { value: client, children });
+const MastraClientProvider = ({ children, baseUrl, headers, apiPrefix, credentials = "include", customFetch }) => {
+	const client = createMastraClient(baseUrl, headers, apiPrefix, credentials, customFetch);
+	return /* @__PURE__ */ jsx(MastraClientContext.Provider, {
+		value: client,
+		children
+	});
 };
 const useMastraClient = () => useContext(MastraClientContext);
-const createMastraClient = (baseUrl, mastraClientHeaders = {}) => {
-  return new MastraClient({
-    baseUrl: baseUrl || "",
-    // only add the header if the baseUrl is not provided i.e it's a local dev environment
-    headers: !baseUrl ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders
-  });
+const IPV4_LOOPBACK_RE = /^127\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+const isIPv4Loopback = (hostname) => {
+	const m = IPV4_LOOPBACK_RE.exec(hostname);
+	if (!m) return false;
+	return +m[1] <= 255 && +m[2] <= 255 && +m[3] <= 255;
 };
-
-const MastraReactProvider = ({ children, baseUrl, headers }) => {
-  return /* @__PURE__ */ jsx(MastraClientProvider, { baseUrl, headers, children });
+const isLocalUrl = (url) => {
+	if (!url) return true;
+	try {
+		const { hostname } = new URL(url);
+		return hostname === "localhost" || hostname.endsWith(".localhost") || isIPv4Loopback(hostname) || hostname === "::1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
 };
-
-const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
-  if (chunk.type === "workflow-start") {
-    return {
-      input: prev?.input,
-      status: "running",
-      steps: prev?.steps || {}
-    };
-  }
-  if (chunk.type === "workflow-canceled") {
-    return {
-      ...prev,
-      status: "canceled"
-    };
-  }
-  if (chunk.type === "workflow-finish") {
-    const finalStatus = chunk.payload.workflowStatus;
-    const prevSteps = prev?.steps ?? {};
-    const lastStep = Object.values(prevSteps).pop();
-    return {
-      ...prev,
-      status: chunk.payload.workflowStatus,
-      ...finalStatus === "success" && lastStep?.status === "success" ? { result: lastStep?.output } : finalStatus === "failed" && lastStep?.status === "failed" ? { error: lastStep?.error } : {}
-    };
-  }
-  const { stepCallId, stepName, ...newPayload } = chunk.payload ?? {};
-  const newSteps = {
-    ...prev?.steps,
-    [chunk.payload.id]: {
-      ...prev?.steps?.[chunk.payload.id],
-      ...newPayload
-    }
-  };
-  if (chunk.type === "workflow-step-start") {
-    return {
-      ...prev,
-      steps: newSteps
-    };
-  }
-  if (chunk.type === "workflow-step-suspended") {
-    const suspendedStepIds = Object.entries(newSteps).flatMap(
-      ([stepId, stepResult]) => {
-        if (stepResult?.status === "suspended") {
-          const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
-          return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
-        }
-        return [];
-      }
-    );
-    return {
-      ...prev,
-      status: "suspended",
-      steps: newSteps,
-      suspendPayload: chunk.payload.suspendPayload,
-      suspended: suspendedStepIds
-    };
-  }
-  if (chunk.type === "workflow-step-waiting") {
-    return {
-      ...prev,
-      status: "waiting",
-      steps: newSteps
-    };
-  }
-  if (chunk.type === "workflow-step-result") {
-    return {
-      ...prev,
-      steps: newSteps
-    };
-  }
-  return prev;
+const createMastraClient = (baseUrl, mastraClientHeaders = {}, apiPrefix, credentials = "include", customFetch) => {
+	return new MastraClient({
+		baseUrl: baseUrl || "",
+		headers: isLocalUrl(baseUrl) ? {
+			...mastraClientHeaders,
+			"x-mastra-dev-playground": "true"
+		} : mastraClientHeaders,
+		apiPrefix,
+		credentials,
+		fetch: customFetch
+	});
 };
-const toUIMessage = ({ chunk, conversation, metadata }) => {
-  const result = [...conversation];
-  switch (chunk.type) {
-    case "tripwire": {
-      const newMessage = {
-        id: `tripwire-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "text",
-            text: chunk.payload.tripwireReason
-          }
-        ],
-        metadata: {
-          ...metadata,
-          status: "warning"
-        }
-      };
-      return [...result, newMessage];
-    }
-    case "start": {
-      const newMessage = {
-        id: `start-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [],
-        metadata
-      };
-      return [...result, newMessage];
-    }
-    case "text-start":
-    case "text-delta": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      let textPartIndex = parts.findIndex((part) => part.type === "text");
-      if (chunk.type === "text-start") {
-        if (textPartIndex === -1) {
-          parts.push({
-            type: "text",
-            text: "",
-            state: "streaming",
-            providerMetadata: chunk.payload.providerMetadata
-          });
-        }
-      } else {
-        if (textPartIndex === -1) {
-          parts.push({
-            type: "text",
-            text: chunk.payload.text,
-            state: "streaming",
-            providerMetadata: chunk.payload.providerMetadata
-          });
-        } else {
-          const textPart = parts[textPartIndex];
-          if (textPart.type === "text") {
-            parts[textPartIndex] = {
-              ...textPart,
-              text: textPart.text + chunk.payload.text,
-              state: "streaming"
-            };
-          }
-        }
-      }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "reasoning-delta": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") {
-        const newMessage = {
-          id: `reasoning-${chunk.runId + Date.now()}`,
-          role: "assistant",
-          parts: [
-            {
-              type: "reasoning",
-              text: chunk.payload.text,
-              state: "streaming",
-              providerMetadata: chunk.payload.providerMetadata
-            }
-          ],
-          metadata
-        };
-        return [...result, newMessage];
-      }
-      const parts = [...lastMessage.parts];
-      let reasoningPartIndex = parts.findIndex((part) => part.type === "reasoning");
-      if (reasoningPartIndex === -1) {
-        parts.push({
-          type: "reasoning",
-          text: chunk.payload.text,
-          state: "streaming",
-          providerMetadata: chunk.payload.providerMetadata
-        });
-      } else {
-        const reasoningPart = parts[reasoningPartIndex];
-        if (reasoningPart.type === "reasoning") {
-          parts[reasoningPartIndex] = {
-            ...reasoningPart,
-            text: reasoningPart.text + chunk.payload.text,
-            state: "streaming"
-          };
-        }
-      }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "tool-call": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") {
-        const newMessage = {
-          id: `tool-call-${chunk.runId + Date.now()}`,
-          role: "assistant",
-          parts: [
-            {
-              type: "dynamic-tool",
-              toolName: chunk.payload.toolName,
-              toolCallId: chunk.payload.toolCallId,
-              state: "input-available",
-              input: chunk.payload.args,
-              callProviderMetadata: chunk.payload.providerMetadata
-            }
-          ],
-          metadata
-        };
-        return [...result, newMessage];
-      }
-      const parts = [...lastMessage.parts];
-      parts.push({
-        type: "dynamic-tool",
-        toolName: chunk.payload.toolName,
-        toolCallId: chunk.payload.toolCallId,
-        state: "input-available",
-        input: chunk.payload.args,
-        callProviderMetadata: chunk.payload.providerMetadata
-      });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "tool-result": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex(
-        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
-      );
-      if (toolPartIndex !== -1) {
-        const toolPart = parts[toolPartIndex];
-        if (toolPart.type === "dynamic-tool") {
-          if (chunk.payload.isError) {
-            parts[toolPartIndex] = {
-              type: "dynamic-tool",
-              toolName: toolPart.toolName,
-              toolCallId: toolPart.toolCallId,
-              state: "output-error",
-              input: toolPart.input,
-              errorText: String(chunk.payload.result),
-              callProviderMetadata: chunk.payload.providerMetadata
-            };
-          } else {
-            const isWorkflow = Boolean(chunk.payload.result?.result?.steps);
-            parts[toolPartIndex] = {
-              type: "dynamic-tool",
-              toolName: toolPart.toolName,
-              toolCallId: toolPart.toolCallId,
-              state: "output-available",
-              input: toolPart.input,
-              output: isWorkflow ? chunk.payload.result?.result : chunk.payload.result,
-              callProviderMetadata: chunk.payload.providerMetadata
-            };
-          }
-        }
-      }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "tool-output": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex(
-        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
-      );
-      if (toolPartIndex !== -1) {
-        const toolPart = parts[toolPartIndex];
-        if (toolPart.type === "dynamic-tool") {
-          if (chunk.payload.output?.type?.startsWith("workflow-")) {
-            const existingWorkflowState = toolPart.output || {};
-            const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(
-              existingWorkflowState,
-              chunk.payload.output
-            );
-            parts[toolPartIndex] = {
-              ...toolPart,
-              output: updatedWorkflowState
-            };
-          } else {
-            const currentOutput = toolPart.output || [];
-            const existingOutput = Array.isArray(currentOutput) ? currentOutput : [];
-            parts[toolPartIndex] = {
-              ...toolPart,
-              output: [...existingOutput, chunk.payload.output]
-            };
-          }
-        }
-      }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "source": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      if (chunk.payload.sourceType === "url") {
-        parts.push({
-          type: "source-url",
-          sourceId: chunk.payload.id,
-          url: chunk.payload.url || "",
-          title: chunk.payload.title,
-          providerMetadata: chunk.payload.providerMetadata
-        });
-      } 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 [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "file": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      let url;
-      if (typeof chunk.payload.data === "string") {
-        url = chunk.payload.base64 ? `data:${chunk.payload.mimeType};base64,${chunk.payload.data}` : `data:${chunk.payload.mimeType},${encodeURIComponent(chunk.payload.data)}`;
-      } else {
-        const base64 = btoa(String.fromCharCode(...chunk.payload.data));
-        url = `data:${chunk.payload.mimeType};base64,${base64}`;
-      }
-      parts.push({
-        type: "file",
-        mediaType: chunk.payload.mimeType,
-        url,
-        providerMetadata: chunk.payload.providerMetadata
-      });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "finish": {
-      const lastMessage = result[result.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = lastMessage.parts.map((part) => {
-        if (part.type === "text" && part.state === "streaming") {
-          return { ...part, state: "done" };
-        }
-        if (part.type === "reasoning" && part.state === "streaming") {
-          return { ...part, state: "done" };
-        }
-        return part;
-      });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    case "error": {
-      const newMessage = {
-        id: `error-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "text",
-            text: typeof chunk.payload.error === "string" ? chunk.payload.error : JSON.stringify(chunk.payload.error)
-          }
-        ],
-        metadata: {
-          ...metadata,
-          status: "error"
-        }
-      };
-      return [...result, newMessage];
-    }
-    // For all other chunk types, return conversation unchanged
-    default:
-      return result;
-  }
+//#endregion
+//#region src/mastra-react-provider.tsx
+const MastraReactProvider = ({ children, baseUrl, headers, apiPrefix, credentials, customFetch }) => {
+	return /* @__PURE__ */ jsx(MastraClientProvider, {
+		baseUrl,
+		headers,
+		apiPrefix,
+		credentials,
+		customFetch,
+		children
+	});
 };
-
-const toAssistantUIMessage = (message) => {
-  const extendedMessage = message;
-  const content = message.parts.map((part) => {
-    if (part.type === "text") {
-      return {
-        type: "text",
-        text: part.text,
-        metadata: message.metadata
-      };
-    }
-    if (part.type === "reasoning") {
-      return {
-        type: "reasoning",
-        text: part.text,
-        metadata: message.metadata
-      };
-    }
-    if (part.type === "source-url") {
-      return {
-        type: "source",
-        sourceType: "url",
-        id: part.sourceId,
-        url: part.url,
-        title: part.title,
-        metadata: message.metadata
-      };
-    }
-    if (part.type === "source-document") {
-      return {
-        type: "file",
-        filename: part.filename,
-        mimeType: part.mediaType,
-        data: "",
-        // Source documents don't have inline data
-        metadata: message.metadata
-      };
-    }
-    if (part.type === "file") {
-      return {
-        type: "file",
-        mimeType: part.mediaType,
-        data: part.url,
-        // Use URL as data source
-        metadata: message.metadata
-      };
-    }
-    if (part.type === "dynamic-tool") {
-      const baseToolCall = {
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        argsText: JSON.stringify(part.input),
-        args: part.input,
-        metadata: message.metadata
-      };
-      if (part.state === "output-error" && "errorText" in part) {
-        return { ...baseToolCall, result: part.errorText, isError: true };
-      }
-      if ("output" in part) {
-        return { ...baseToolCall, result: part.output };
-      }
-      return baseToolCall;
-    }
-    if (part.type.startsWith("tool-") && part.state !== "input-available") {
-      const toolName = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.substring(5);
-      const baseToolCall = {
-        type: "tool-call",
-        toolCallId: "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "",
-        toolName,
-        argsText: "input" in part ? JSON.stringify(part.input) : "{}",
-        args: "input" in part ? part.input : {},
-        metadata: message.metadata
-      };
-      if ("output" in part) {
-        return { ...baseToolCall, result: part.output };
-      } else if ("error" in part) {
-        return { ...baseToolCall, result: part.error, isError: true };
-      }
-      return baseToolCall;
-    }
-    return {
-      type: "text",
-      text: "",
-      metadata: message.metadata
-    };
-  });
-  let status;
-  if (message.role === "assistant" && content.length > 0) {
-    const hasStreamingParts = message.parts.some(
-      (part) => part.type === "text" && "state" in part && part.state === "streaming" || part.type === "reasoning" && "state" in part && part.state === "streaming"
-    );
-    const hasToolCalls = message.parts.some((part) => part.type === "dynamic-tool" || part.type.startsWith("tool-"));
-    const hasInputAvailableTools = message.parts.some(
-      (part) => part.type === "dynamic-tool" && part.state === "input-available"
-    );
-    const hasErrorTools = message.parts.some(
-      (part) => part.type === "dynamic-tool" && part.state === "output-error" || part.type.startsWith("tool-") && "error" in part
-    );
-    if (hasStreamingParts) {
-      status = { type: "running" };
-    } else if (hasInputAvailableTools && hasToolCalls) {
-      status = { type: "requires-action", reason: "tool-calls" };
-    } else if (hasErrorTools) {
-      status = { type: "incomplete", reason: "error" };
-    } else {
-      status = { type: "complete", reason: "stop" };
-    }
-  }
-  const threadMessage = {
-    role: message.role,
-    content,
-    id: message.id,
-    createdAt: extendedMessage.createdAt,
-    status,
-    attachments: extendedMessage.experimental_attachments
-  };
-  return threadMessage;
+//#endregion
+//#region 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);
 };
-
-class AISdkNetworkTransformer {
-  transform({ chunk, conversation, metadata }) {
-    const newConversation = [...conversation];
-    if (chunk.type === "routing-agent-text-delta") {
-      return this.handleRoutingAgentConversation(chunk, newConversation);
-    }
-    if (chunk.type.startsWith("agent-execution-")) {
-      return this.handleAgentConversation(chunk, newConversation, metadata);
-    }
-    if (chunk.type.startsWith("workflow-execution-")) {
-      return this.handleWorkflowConversation(chunk, newConversation, metadata);
-    }
-    if (chunk.type.startsWith("tool-execution-")) {
-      return this.handleToolConversation(chunk, newConversation, metadata);
-    }
-    if (chunk.type === "network-execution-event-step-finish") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const agentChunk = chunk.payload;
-      const parts = [...lastMessage.parts];
-      const textPartIndex = parts.findIndex((part) => part.type === "text");
-      if (textPartIndex === -1) {
-        parts.push({
-          type: "text",
-          text: agentChunk.result,
-          state: "done"
-        });
-        return [
-          ...newConversation.slice(0, -1),
-          {
-            ...lastMessage,
-            parts
-          }
-        ];
-      }
-      const textPart = parts[textPartIndex];
-      if (textPart.type === "text") {
-        parts[textPartIndex] = {
-          ...textPart,
-          state: "done"
-        };
-        return [
-          ...newConversation.slice(0, -1),
-          {
-            ...lastMessage,
-            parts
-          }
-        ];
-      }
-      return newConversation;
-    }
-    return newConversation;
-  }
-  handleRoutingAgentConversation = (chunk, newConversation) => {
-    const lastMessage = newConversation[newConversation.length - 1];
-    if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-    const agentChunk = chunk.payload;
-    const parts = [...lastMessage.parts];
-    const textPartIndex = parts.findIndex((part) => part.type === "text");
-    if (textPartIndex === -1) {
-      parts.push({
-        type: "text",
-        text: agentChunk.text,
-        state: "streaming"
-      });
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    const textPart = parts[textPartIndex];
-    if (textPart.type === "text") {
-      parts[textPartIndex] = {
-        ...textPart,
-        text: textPart.text + agentChunk.text,
-        state: "streaming"
-      };
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    return newConversation;
-  };
-  handleAgentConversation = (chunk, newConversation, metadata) => {
-    if (chunk.type === "agent-execution-start") {
-      const primitiveId = chunk.payload?.args?.primitiveId;
-      const runId = chunk.payload.runId;
-      if (!primitiveId || !runId) return newConversation;
-      const newMessage = {
-        id: `agent-execution-start-${runId}-${Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "dynamic-tool",
-            toolName: primitiveId,
-            toolCallId: runId,
-            state: "input-available",
-            input: chunk.payload.args
-          }
-        ],
-        metadata: {
-          ...metadata,
-          selectionReason: chunk.payload?.args?.selectionReason || "",
-          agentInput: chunk.payload?.args?.task,
-          mode: "network",
-          from: "AGENT"
-        }
-      };
-      return [...newConversation, newMessage];
-    }
-    if (chunk.type === "agent-execution-end") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
-      if (toolPartIndex !== -1) {
-        const toolPart = parts[toolPartIndex];
-        if (toolPart.type === "dynamic-tool") {
-          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 [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    if (chunk.type.startsWith("agent-execution-event-")) {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const agentChunk = chunk.payload;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
-      if (toolPartIndex === -1) return newConversation;
-      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 [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    return newConversation;
-  };
-  handleWorkflowConversation = (chunk, newConversation, metadata) => {
-    if (chunk.type === "workflow-execution-start") {
-      const primitiveId = chunk.payload?.args?.primitiveId;
-      const runId = chunk.payload.runId;
-      if (!primitiveId || !runId) return newConversation;
-      let agentInput;
-      try {
-        agentInput = JSON.parse(chunk?.payload?.args?.prompt);
-      } catch (e) {
-        agentInput = chunk?.payload?.args?.prompt;
-      }
-      const newMessage = {
-        id: `workflow-start-${runId}-${Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "dynamic-tool",
-            toolName: primitiveId,
-            toolCallId: runId,
-            state: "input-available",
-            input: chunk.payload.args
-          }
-        ],
-        metadata: {
-          ...metadata,
-          selectionReason: chunk.payload?.args?.selectionReason || "",
-          from: "WORKFLOW",
-          mode: "network",
-          agentInput
-        }
-      };
-      return [...newConversation, newMessage];
-    }
-    if (chunk.type.startsWith("workflow-execution-event-")) {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
-      if (toolPartIndex === -1) return newConversation;
-      const toolPart = parts[toolPartIndex];
-      if (toolPart.type !== "dynamic-tool") return newConversation;
-      const existingWorkflowState = toolPart.output || {};
-      const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload);
-      parts[toolPartIndex] = {
-        ...toolPart,
-        output: updatedWorkflowState
-      };
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    return newConversation;
-  };
-  handleToolConversation = (chunk, newConversation, metadata) => {
-    if (chunk.type === "tool-execution-start") {
-      const { args: argsData } = chunk.payload;
-      const lastMessage = newConversation[newConversation.length - 1];
-      const nestedArgs = argsData.args || {};
-      if (!lastMessage || lastMessage.role !== "assistant") {
-        const newMessage = {
-          id: `tool-start-${chunk.runId}-${Date.now()}`,
-          role: "assistant",
-          parts: [
-            {
-              type: "dynamic-tool",
-              toolName: argsData.toolName || "unknown",
-              toolCallId: argsData.toolCallId || "unknown",
-              state: "input-available",
-              input: nestedArgs
-            }
-          ],
-          metadata: {
-            ...metadata,
-            selectionReason: metadata?.mode === "network" ? metadata.selectionReason || argsData.selectionReason : "",
-            mode: "network",
-            agentInput: nestedArgs
-          }
-        };
-        return [...newConversation, newMessage];
-      }
-      const parts = [...lastMessage.parts];
-      parts.push({
-        type: "dynamic-tool",
-        toolName: argsData.toolName || "unknown",
-        toolCallId: argsData.toolCallId || "unknown",
-        state: "input-available",
-        input: nestedArgs
-      });
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    if (chunk.type === "tool-execution-end") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const parts = [...lastMessage.parts];
-      const toolPartIndex = parts.findIndex(
-        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
-      );
-      if (toolPartIndex !== -1) {
-        const toolPart = parts[toolPartIndex];
-        if (toolPart.type === "dynamic-tool") {
-          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 [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    return newConversation;
-  };
+function convertSignalDataToBase64String(content) {
+	if (typeof content === "string") return content;
+	const bytes = content instanceof ArrayBuffer ? new Uint8Array(content) : content;
+	return uint8ArrayToBase64(bytes);
 }
-
-const resolveInitialMessages = (messages) => {
-  return messages.map((message) => {
-    const networkPart = message.parts.find((part) => part.type === "text" && part.text.includes('"isNetwork":true'));
-    if (networkPart && networkPart.type === "text") {
-      try {
-        const json = JSON.parse(networkPart.text);
-        if (json.isNetwork === true) {
-          const selectionReason = json.selectionReason || "";
-          const primitiveType = json.primitiveType || "";
-          const primitiveId = json.primitiveId || "";
-          const finalResult = json.finalResult;
-          const toolCalls = finalResult?.toolCalls || [];
-          const childMessages = [];
-          for (const toolCall of toolCalls) {
-            if (toolCall.type === "tool-call" && toolCall.payload) {
-              const toolCallId = toolCall.payload.toolCallId;
-              let toolResult;
-              for (const message2 of finalResult?.messages || []) {
-                for (const part of message2.content || []) {
-                  if (typeof part === "object" && part.type === "tool-result" && part.toolCallId === toolCallId) {
-                    toolResult = part;
-                    break;
-                  }
-                }
-              }
-              const isWorkflow = Boolean(toolResult?.result?.result?.steps);
-              childMessages.push({
-                type: "tool",
-                toolCallId: toolCall.payload.toolCallId,
-                toolName: toolCall.payload.toolName,
-                args: toolCall.payload.args,
-                toolOutput: isWorkflow ? toolResult?.result?.result : toolResult?.result
-              });
-            }
-          }
-          if (finalResult && finalResult.text) {
-            childMessages.push({
-              type: "text",
-              content: finalResult.text
-            });
-          }
-          const result = {
-            childMessages,
-            result: finalResult?.text || ""
-          };
-          console.log("json", json);
-          const nextMessage = {
-            role: "assistant",
-            parts: [
-              {
-                type: "dynamic-tool",
-                toolCallId: primitiveId,
-                toolName: primitiveId,
-                state: "output-available",
-                input: json.input,
-                output: result
-              }
-            ],
-            id: message.id,
-            metadata: {
-              ...message.metadata,
-              mode: "network",
-              selectionReason,
-              agentInput: json.input,
-              from: primitiveType === "agent" ? "AGENT" : "WORKFLOW"
-            }
-          };
-          return nextMessage;
-        }
-      } catch (error) {
-        return message;
-      }
-    }
-    return message;
-  });
+/** 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}`;
+}
+//#endregion
+//#region 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 useChat = ({ agentId, initializeMessages }) => {
-  const [messages, setMessages] = useState(
-    () => resolveInitialMessages(initializeMessages?.() || [])
-  );
-  const baseClient = useMastraClient();
-  const [isRunning, setIsRunning] = useState(false);
-  const generate = async ({
-    coreUserMessages,
-    runtimeContext,
-    threadId,
-    modelSettings,
-    signal,
-    onFinish
-  }) => {
-    const {
-      frequencyPenalty,
-      presencePenalty,
-      maxRetries,
-      maxTokens,
-      temperature,
-      topK,
-      topP,
-      instructions,
-      providerOptions,
-      maxSteps
-    } = modelSettings || {};
-    setIsRunning(true);
-    const clientWithAbort = new MastraClient({
-      ...baseClient.options,
-      abortSignal: signal
-    });
-    const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.generate({
-      messages: coreUserMessages,
-      runId: agentId,
-      maxSteps,
-      modelSettings: {
-        frequencyPenalty,
-        presencePenalty,
-        maxRetries,
-        maxOutputTokens: maxTokens,
-        temperature,
-        topK,
-        topP
-      },
-      instructions,
-      runtimeContext,
-      ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
-    });
-    setIsRunning(false);
-    if (response && "uiMessages" in response.response && response.response.uiMessages) {
-      onFinish?.(response.response.uiMessages);
-      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
-        ...message,
-        metadata: {
-          mode: "generate"
-        }
-      }));
-      setMessages((prev) => [...prev, ...mastraUIMessages]);
-    }
-  };
-  const stream = async ({ coreUserMessages, runtimeContext, threadId, onChunk, modelSettings, signal }) => {
-    const {
-      frequencyPenalty,
-      presencePenalty,
-      maxRetries,
-      maxTokens,
-      temperature,
-      topK,
-      topP,
-      instructions,
-      providerOptions,
-      maxSteps
-    } = modelSettings || {};
-    setIsRunning(true);
-    const clientWithAbort = new MastraClient({
-      ...baseClient.options,
-      abortSignal: signal
-    });
-    const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.stream({
-      messages: coreUserMessages,
-      runId: agentId,
-      maxSteps,
-      modelSettings: {
-        frequencyPenalty,
-        presencePenalty,
-        maxRetries,
-        maxOutputTokens: maxTokens,
-        temperature,
-        topK,
-        topP
-      },
-      instructions,
-      runtimeContext,
-      ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
-    });
-    if (!response.body) {
-      setIsRunning(false);
-      throw new Error("[Stream] No response body");
-    }
-    await response.processDataStream({
-      onChunk: async (chunk) => {
-        setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
-        onChunk?.(chunk);
-      }
-    });
-    setIsRunning(false);
-  };
-  const network = async ({
-    coreUserMessages,
-    runtimeContext,
-    threadId,
-    onNetworkChunk,
-    modelSettings,
-    signal
-  }) => {
-    const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
-    setIsRunning(true);
-    const clientWithAbort = new MastraClient({
-      ...baseClient.options,
-      abortSignal: signal
-    });
-    const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.network({
-      messages: coreUserMessages,
-      maxSteps,
-      modelSettings: {
-        frequencyPenalty,
-        presencePenalty,
-        maxRetries,
-        maxOutputTokens: maxTokens,
-        temperature,
-        topK,
-        topP
-      },
-      runId: agentId,
-      runtimeContext,
-      ...threadId ? { thread: threadId, resourceId: agentId } : {}
-    });
-    const transformer = new AISdkNetworkTransformer();
-    await response.processDataStream({
-      onChunk: async (chunk) => {
-        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
-        onNetworkChunk?.(chunk);
-      }
-    });
-    setIsRunning(false);
-  };
-  const sendMessage = async ({ mode = "stream", ...args }) => {
-    const nextMessage = { role: "user", content: [{ type: "text", text: args.message }] };
-    const messages2 = args.coreUserMessages ? [nextMessage, ...args.coreUserMessages] : [nextMessage];
-    setMessages((s) => [...s, { role: "user", parts: [{ type: "text", text: args.message }] }]);
-    if (mode === "generate") {
-      await generate({ ...args, coreUserMessages: messages2 });
-    } else if (mode === "stream") {
-      await stream({ ...args, coreUserMessages: messages2 });
-    } else if (mode === "network") {
-      await network({ ...args, coreUserMessages: messages2 });
-    }
-  };
-  return {
-    setMessages,
-    sendMessage,
-    isRunning,
-    messages,
-    cancelRun: () => setIsRunning(false)
-  };
+const formatCompletionFeedback = (result, maxIterationReached) => {
+	return formatBaseCompletionFeedback(result, maxIterationReached, (scorer) => `###### ${scorer.scorerName} (${scorer.scorerId})`, "🔄 Will continue working on the task.");
 };
-
-const EntityContext = createContext({
-  expanded: false,
-  setExpanded: () => {
-  },
-  variant: "initial",
-  disabled: false
+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.");
+};
+//#endregion
+//#region 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";
+//#endregion
+//#region src/lib/mastra-db/accumulator.ts
+const cloneMetadata = (metadata) => metadata ? { ...metadata } : {};
+const withParts = (message, parts) => ({
+	...message,
+	content: {
+		...message.content,
+		parts
+	}
 });
-const EntityProvider = EntityContext.Provider;
-const useEntity = () => useContext(EntityContext);
-
-const IconSizes = {
-  sm: "mastra:[&>svg]:size-3",
-  md: "mastra:[&>svg]:size-4",
-  lg: "mastra:[&>svg]:size-5"
+const withMetadata = (message, metadata) => ({
+	...message,
+	content: {
+		...message.content,
+		metadata
+	}
+});
+const clearPendingStatus = (message) => {
+	const { status: _status, [CLIENT_MESSAGE_ID_KEY]: _clientMessageId, ...rest } = message.content.metadata ?? {};
+	return withMetadata(message, rest);
 };
-const Icon = ({ children, className, size = "md", ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || IconSizes[size], ...props, children });
+const clearPendingStatusKeepClientId = (message) => {
+	const { status: _status, ...rest } = message.content.metadata ?? {};
+	return withMetadata(message, rest);
 };
-
-const Entity = ({
-  className,
-  variant = "initial",
-  initialExpanded = false,
-  disabled = false,
-  ...props
-}) => {
-  const [expanded, setExpanded] = useState(initialExpanded);
-  return /* @__PURE__ */ jsx(EntityProvider, { value: { expanded, setExpanded, variant, disabled }, children: /* @__PURE__ */ jsx("div", { className, ...props }) });
+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));
 };
-const EntityTriggerClass = twMerge(
-  "mastra:aria-disabled:cursor-not-allowed mastra:aria-disabled:bg-surface5 mastra:aria-disabled:text-text3",
-  "mastra:aria-expanded:rounded-b-none mastra:aria-expanded:border-b-0",
-  "mastra:bg-surface3 mastra:text-text6 mastra:hover:bg-surface4 mastra:active:bg-surface5",
-  "mastra:rounded-lg mastra:py-2 mastra:px-4 mastra:border mastra:border-border1",
-  "mastra:cursor-pointer mastra:inline-flex mastra:items-center mastra:gap-1 mastra:font-mono"
-);
-const EntityTriggerVariantClasses = {
-  agent: "mastra:[&_svg.mastra-icon]:text-accent1",
-  workflow: "mastra:[&_svg.mastra-icon]:text-accent3",
-  tool: "mastra:[&_svg.mastra-icon]:text-accent6",
-  memory: "mastra:[&_svg.mastra-icon]:text-accent2",
-  initial: "mastra:[&_svg.mastra-icon]:text-text3"
+/**
+* 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;
 };
-const EntityTrigger = ({ className, children, ...props }) => {
-  const { expanded, setExpanded, variant, disabled } = useEntity();
-  const handleClick = (e) => {
-    if (disabled) return;
-    setExpanded(!expanded);
-    props?.onClick?.(e);
-  };
-  return /* @__PURE__ */ jsx(
-    "button",
-    {
-      className: className || twMerge(EntityTriggerClass, !disabled && EntityTriggerVariantClasses[variant]),
-      ...props,
-      onClick: handleClick,
-      "aria-expanded": expanded,
-      "aria-disabled": disabled,
-      children
-    }
-  );
+/**
+* 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;
 };
-const EntityContentClass = twMerge(
-  "mastra:space-y-4",
-  "mastra:rounded-lg mastra:rounded-tl-none mastra:p-4 mastra:border mastra:border-border1 mastra:-mt-[0.5px]",
-  "mastra:bg-surface3 mastra:text-text6"
-);
-const EntityContent = ({ className, ...props }) => {
-  const { expanded } = useEntity();
-  if (!expanded) return null;
-  return /* @__PURE__ */ jsx("div", { className: className || EntityContentClass, ...props });
+/**
+* Workflow chunk accumulation. Mirrors
+* `mapWorkflowStreamChunkToWatchResult` from the previous accumulator.
+*/
+const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+	if (chunk.type === "workflow-start") return {
+		input: prev?.input,
+		status: "running",
+		steps: prev?.steps || {}
+	};
+	if (chunk.type === "workflow-canceled") return {
+		...prev,
+		status: "canceled"
+	};
+	if (chunk.type === "workflow-finish") {
+		const finalStatus = chunk.payload.workflowStatus;
+		const prevSteps = prev?.steps ?? {};
+		const lastStep = Object.values(prevSteps).pop();
+		return {
+			...prev,
+			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,
+		[chunk.payload.id]: {
+			...prev?.steps?.[chunk.payload.id],
+			...newPayload
+		}
+	};
+	if (chunk.type === "workflow-step-start") return {
+		...prev,
+		steps: newSteps
+	};
+	if (chunk.type === "workflow-step-suspended") {
+		const suspendedStepIds = Object.entries(newSteps).flatMap(([stepId, stepResult]) => {
+			if (stepResult?.status === "suspended") {
+				const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
+				return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
+			}
+			return [];
+		});
+		return {
+			...prev,
+			status: "suspended",
+			steps: newSteps,
+			suspendPayload: chunk.payload.suspendPayload,
+			suspended: suspendedStepIds
+		};
+	}
+	if (chunk.type === "workflow-step-waiting") return {
+		...prev,
+		status: "waiting",
+		steps: newSteps
+	};
+	if (chunk.type === "workflow-step-progress") return {
+		...prev,
+		steps: {
+			...prev?.steps,
+			[chunk.payload.id]: {
+				...prev?.steps?.[chunk.payload.id],
+				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 {
+		...prev,
+		steps: newSteps
+	};
+	return prev;
 };
-const EntityCaret = ({ className, ...props }) => {
-  const { expanded } = useEntity();
-  return /* @__PURE__ */ jsx(Icon, { children: /* @__PURE__ */ jsx(
-    ChevronDownIcon,
-    {
-      className: twMerge(
-        `mastra:text-text3 mastra:transition-transform mastra:duration-200 mastra:ease-in-out`,
-        expanded ? "mastra:rotate-0" : "mastra:-rotate-90",
-        className
-      ),
-      ...props
-    }
-  ) });
+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 ToolApprovalClass = twMerge(
-  "mastra:rounded-lg mastra:border mastra:border-border1 mastra:max-w-1/2 mastra:mt-2",
-  "mastra:bg-surface3 mastra:text-text6"
-);
-const ToolApproval = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || ToolApprovalClass, ...props });
+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 ToolApprovalTitleClass = twMerge("mastra:text-text6 mastra:inline-flex mastra:items-center mastra:gap-1");
-const ToolApprovalTitle = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || ToolApprovalTitleClass, ...props });
+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$2 = (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 accumulateChunk = ({ chunk, conversation, metadata }) => {
+	const result = [...conversation];
+	if (isTemplateLiteralPassthrough(chunk)) return result;
+	if (isDataChunk$2(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),
+				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
+							},
+							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),
+				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;
+					break;
+			}
+			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 error = chunk.type === "tool-error" || chunk.type === "background-task-failed" ? payloadError : payloadResult;
+					const errorText = typeof error === "string" ? error : error instanceof Error ? error.message : error?.message ?? String(error);
+					parts[toolPartIndex] = {
+						...toolPart,
+						providerMetadata: providerMeta,
+						toolInvocation: {
+							state: "output-error",
+							toolCallId,
+							toolName,
+							args,
+							errorText
+						}
+					};
+				} 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 === "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 (payloadOutput?.from === "AGENT" || payloadOutput?.from === "USER" && payloadOutput?.payload?.output?.type?.startsWith("workflow-")) return accumulateAgentChunk(payloadOutput, result, metadata, toolCallId, toolName);
+			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.toolName]: {
+								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 "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 (!lastMessage || lastMessage.role !== "assistant") return result;
+			if (result.some((message) => message.id === stepMessageId)) return result;
+			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":
+		case "tool-output-denied": return result;
+		default: return assertExhaustive(chunk, result);
+	}
 };
-const ToolApprovalHeaderClass = twMerge(
-  "mastra:flex mastra:justify-between mastra:items-center mastra:gap-2",
-  "mastra:border-b mastra:border-border1 mastra:px-4 mastra:py-2"
-);
-const ToolApprovalHeader = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || ToolApprovalHeaderClass, ...props });
+/**
+* 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 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));
+	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 lastChildMessage = childMessages[childMessages.length - 1];
+		const textMessage = {
+			type: "text",
+			content: (lastChildMessage?.content || "") + agentChunk.text
+		};
+		const nextChildren = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+		parts[toolPartIndex] = {
+			...toolPart,
+			toolInvocation: {
+				...toolPart.toolInvocation,
+				result: {
+					...existingResult,
+					childMessages: nextChildren
+				}
+			}
+		};
+	} 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
+					}]
+				}
+			}
+		};
+	} 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 replaceLast(conversation, withParts(lastMessage, parts));
 };
-const ToolApprovalContentClass = twMerge("mastra:text-text6 mastra:p-4");
-const ToolApprovalContent = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || ToolApprovalContentClass, ...props });
+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;
 };
-const ToolApprovalActionsClass = twMerge("mastra:flex mastra:gap-2 mastra:items-center");
-const ToolApprovalActions = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || ToolApprovalActionsClass, ...props });
+/**
+* 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;
+	}
 };
-
-const EntryClass = "mastra:space-y-2";
-const Entry = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || EntryClass, ...props });
+/**
+* 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 EntryTitleClass = "mastra:font-mono mastra:text-sm mastra:text-text3";
-const EntryTitle = ({ className, as: Root = "h3", ...props }) => {
-  return /* @__PURE__ */ jsx(Root, { className: className || EntryTitleClass, ...props });
+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;
 };
-
-async function highlight(code, lang) {
-  const out = await codeToHast(code, {
-    lang,
-    theme: "dracula-soft"
-  });
-  return toJsxRuntime(out, {
-    Fragment,
-    jsx,
-    jsxs
-  });
-}
-
-const Tooltip = ({ children }) => {
-  return /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsx(Root, { children }) });
+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 TooltipContentClass = "mastra:bg-surface4 mastra:text-text6 mastra mastra:rounded-lg mastra:py-1 mastra:px-2 mastra:text-xs mastra:border mastra:border-border1 mastra-tooltip-enter";
-const TooltipContent = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx(TooltipPortal, { children: /* @__PURE__ */ jsx(TooltipContent$1, { className: className || TooltipContentClass, ...props, children }) });
+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;
 };
-const TooltipTrigger = (props) => {
-  return /* @__PURE__ */ jsx(TooltipTrigger$1, { ...props, asChild: true });
+/**
+* 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;
 };
-
-const IconButtonClass = "mastra:text-text3 mastra:hover:text-text6 mastra:active:text-text6 mastra:hover:bg-surface4 mastra:active:bg-surface5 mastra:rounded-md mastra:cursor-pointer";
-const IconButton = ({ children, tooltip, size = "md", className, ...props }) => {
-  return /* @__PURE__ */ jsxs(Tooltip, { children: [
-    /* @__PURE__ */ jsx(TooltipTrigger, { children: /* @__PURE__ */ jsx(
-      "button",
-      {
-        ...props,
-        className: className || twMerge(IconButtonClass, size === "md" && "mastra:p-0.5", size === "lg" && "mastra:p-1"),
-        children: /* @__PURE__ */ jsx(Icon, { size, children })
-      }
-    ) }),
-    /* @__PURE__ */ jsx(TooltipContent, { children: tooltip })
-  ] });
+//#endregion
+//#region src/lib/mastra-db/fromCoreUserMessage.ts
+/**
+* Convert a CoreUserMessage into a canonical `MastraDBMessage` (`format: 2`).
+*
+* Image and file inputs are emitted as the canonical V4 `file` part shape
+* (`{ type: 'file', mimeType, data }`) — the exact shape memory resolves on
+* reload (see `AIV4Adapter`), so optimistic-send and reload render identically.
+*
+* Handles all CoreUserMessage content types:
+* - String content → single text part
+* - Array content with text/image/file parts → corresponding `MastraMessagePart`s
+*/
+const coreUserMessageToParts = (coreUserMessage) => typeof coreUserMessage.content === "string" ? [{
+	type: "text",
+	text: coreUserMessage.content
+}] : coreUserMessage.content.map((part) => {
+	switch (part.type) {
+		case "text": return {
+			type: "text",
+			text: part.text
+		};
+		case "image": {
+			const mimeType = part.mimeType ?? "image/*";
+			return {
+				type: "file",
+				mimeType,
+				data: encodeFilePartDataForStorage(part.image, mimeType)
+			};
+		}
+		case "file": return {
+			type: "file",
+			mimeType: part.mimeType,
+			data: encodeFilePartDataForStorage(part.data, part.mimeType),
+			...part.filename !== void 0 ? { filename: part.filename } : {}
+		};
+		default: throw new Error(`Unhandled content part type: ${part.type}`);
+	}
+});
+const newUserMessage = (parts) => ({
+	id: `user-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+	role: "user",
+	createdAt: /* @__PURE__ */ new Date(),
+	content: {
+		format: 2,
+		parts
+	}
+});
+const fromCoreUserMessageToMastraDBMessage = (coreUserMessage) => newUserMessage(coreUserMessageToParts(coreUserMessage));
+/**
+* Merge multiple `CoreUserMessage`s into a single canonical `MastraDBMessage`.
+*
+* A user turn that carries attachments arrives as several `CoreUserMessage`s
+* (one for the text, one per attachment). Memory/reload persists and resolves
+* that whole turn as a single multi-part user message, so the optimistic
+* streaming display must do the same — flatten every message's parts into one
+* `parts` array — to render identically (one bubble, not one per message).
+*/
+const fromCoreUserMessagesToMastraDBMessage = (coreUserMessages) => newUserMessage(coreUserMessages.flatMap(coreUserMessageToParts));
+//#endregion
+//#region src/agent/extract-tasks.ts
+const TASK_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task_write",
+	"task_update",
+	"task_complete",
+	"task_check"
+]);
+const TASK_SIGNAL_ID = "tasks";
+const TASK_TAG_NAMES = /* @__PURE__ */ new Set(["current-task-list", "task-list-update"]);
+const TASK_STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"in_progress",
+	"completed"
+]);
+const isDataChunk$1 = (chunk) => typeof chunk.type === "string" && chunk.type.startsWith("data-");
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isTaskStatus = (value) => typeof value === "string" && TASK_STATUSES.has(value);
+const isTaskItemArray = (value) => Array.isArray(value) && value.every((item) => isRecord$1(item) && typeof item.id === "string" && typeof item.content === "string" && isTaskStatus(item.status) && typeof item.activeForm === "string");
+const isTaskSignal = (value) => {
+	if (!isRecord$1(value)) return false;
+	return value.id === TASK_SIGNAL_ID || typeof value.tagName === "string" && TASK_TAG_NAMES.has(value.tagName);
 };
-
-const CodeBlockClass = "mastra:rounded-lg mastra:[&>pre]:p-4 mastra:overflow-hidden mastra:[&>pre]:!bg-surface4 mastra:[&>pre>code]:leading-5 mastra:relative";
-const CodeBlock = ({ code, language, className, cta }) => {
-  const [nodes, setNodes] = useState(null);
-  useLayoutEffect(() => {
-    void highlight(code, language).then(setNodes);
-  }, [language]);
-  return /* @__PURE__ */ jsxs("div", { className: className || CodeBlockClass, children: [
-    nodes ?? null,
-    cta
-  ] });
+const extractTasksFromSignalData = (data) => {
+	if (!isTaskSignal(data) || !isRecord$1(data)) return void 0;
+	const metadata = data.metadata;
+	if (!isRecord$1(metadata)) return void 0;
+	const value = metadata.value;
+	if (!isRecord$1(value)) return void 0;
+	return isTaskItemArray(value.tasks) ? value.tasks : void 0;
 };
-const CodeCopyButton = ({ code }) => {
-  const [isCopied, setIsCopied] = useState(false);
-  const handleCopy = () => {
-    navigator.clipboard.writeText(code);
-    setIsCopied(true);
-    setTimeout(() => setIsCopied(false), 2e3);
-  };
-  return /* @__PURE__ */ jsx("div", { className: "mastra:absolute mastra:top-2 mastra:right-2", children: /* @__PURE__ */ jsx(IconButton, { tooltip: "Copy", onClick: handleCopy, children: isCopied ? /* @__PURE__ */ jsx(CheckIcon, {}) : /* @__PURE__ */ jsx(CopyIcon, {}) }) });
+const parseTasksFromResult = (raw) => {
+	if (isRecord$1(raw) && isTaskItemArray(raw.tasks)) return raw.tasks;
+	if (typeof raw !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		return isRecord$1(parsed) && isTaskItemArray(parsed.tasks) ? parsed.tasks : void 0;
+	} catch {
+		return;
+	}
 };
-
-const AgentIcon = ({ className, ...props }) => /* @__PURE__ */ jsxs(
-  "svg",
-  {
-    width: "17",
-    height: "16",
-    viewBox: "0 0 17 16",
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg",
-    ...props,
-    className: twMerge("mastra-icon", className),
-    children: [
-      /* @__PURE__ */ jsx(
-        "path",
-        {
-          fillRule: "evenodd",
-          clipRule: "evenodd",
-          d: "M8.5 15C10.3565 15 12.137 14.2625 13.4497 12.9497C14.7625 11.637 15.5 9.85652 15.5 8C15.5 6.14348 14.7625 4.36301 13.4497 3.05025C12.137 1.7375 10.3565 1 8.5 1C6.64348 1 4.86301 1.7375 3.55025 3.05025C2.2375 4.36301 1.5 6.14348 1.5 8C1.5 9.85652 2.2375 11.637 3.55025 12.9497C4.86301 14.2625 6.64348 15 8.5 15ZM5.621 10.879L4.611 11.889C3.84179 11.1198 3.31794 10.1398 3.1057 9.07291C2.89346 8.00601 3.00236 6.90013 3.41864 5.89512C3.83491 4.89012 4.53986 4.03112 5.44434 3.42676C6.34881 2.8224 7.41219 2.49983 8.5 2.49983C9.58781 2.49983 10.6512 2.8224 11.5557 3.42676C12.4601 4.03112 13.1651 4.89012 13.5814 5.89512C13.9976 6.90013 14.1065 8.00601 13.8943 9.07291C13.6821 10.1398 13.1582 11.1198 12.389 11.889L11.379 10.879C11.1004 10.6003 10.7696 10.3792 10.4055 10.2284C10.0414 10.0776 9.6511 9.99995 9.257 10H7.743C7.3489 9.99995 6.95865 10.0776 6.59455 10.2284C6.23045 10.3792 5.89963 10.6003 5.621 10.879Z",
-          fill: "currentColor"
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        "path",
-        {
-          d: "M8.5 4C7.96957 4 7.46086 4.21071 7.08579 4.58579C6.71071 4.96086 6.5 5.46957 6.5 6V6.5C6.5 7.03043 6.71071 7.53914 7.08579 7.91421C7.46086 8.28929 7.96957 8.5 8.5 8.5C9.03043 8.5 9.53914 8.28929 9.91421 7.91421C10.2893 7.53914 10.5 7.03043 10.5 6.5V6C10.5 5.46957 10.2893 4.96086 9.91421 4.58579C9.53914 4.21071 9.03043 4 8.5 4Z",
-          fill: "currentColor"
-        }
-      )
-    ]
-  }
-);
-
-const ToolsIcon = ({ className, ...props }) => /* @__PURE__ */ jsx(
-  "svg",
-  {
-    width: "17",
-    height: "16",
-    viewBox: "0 0 17 16",
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg",
-    ...props,
-    className: twMerge("mastra-icon", className),
-    children: /* @__PURE__ */ jsx(
-      "path",
-      {
-        fillRule: "evenodd",
-        clipRule: "evenodd",
-        d: "M7.5605 1.42351C8.0791 0.904904 8.92215 0.906157 9.4395 1.42351L10.6922 2.67617C11.2108 3.19477 11.2095 4.03782 10.6922 4.55517L9.4395 5.80783C8.9209 6.32643 8.07785 6.32518 7.5605 5.80783L6.30784 4.55517C5.78923 4.03656 5.79049 3.19352 6.30784 2.67617L7.5605 1.42351ZM3.17618 5.80783C3.69478 5.28923 4.53782 5.29048 5.05517 5.80783L6.30784 7.0605C6.82644 7.5791 6.82519 8.42214 6.30784 8.93949L5.05517 10.1922C4.53657 10.7108 3.69353 10.7095 3.17618 10.1922L1.92351 8.93949C1.40491 8.42089 1.40616 7.57785 1.92351 7.0605L3.17618 5.80783ZM11.9448 5.80783C12.4634 5.28923 13.3065 5.29048 13.8238 5.80783L15.0765 7.0605C15.5951 7.5791 15.5938 8.42214 15.0765 8.93949L13.8238 10.1922C13.3052 10.7108 12.4622 10.7095 11.9448 10.1922L10.6922 8.93949C10.1736 8.42089 10.1748 7.57785 10.6922 7.0605L11.9448 5.80783ZM7.5605 10.1922C8.0791 9.67355 8.92215 9.67481 9.4395 10.1922L10.6922 11.4448C11.2108 11.9634 11.2095 12.8065 10.6922 13.3238L9.4395 14.5765C8.9209 15.0951 8.07785 15.0938 7.5605 14.5765L6.30784 13.3238C5.78923 12.8052 5.79049 11.9622 6.30784 11.4448L7.5605 10.1922Z",
-        fill: "currentColor"
-      }
-    )
-  }
-);
-
-const WorkflowIcon = ({ className, ...props }) => /* @__PURE__ */ jsx(
-  "svg",
-  {
-    width: "17",
-    height: "16",
-    viewBox: "0 0 17 16",
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg",
-    ...props,
-    className: twMerge("mastra-icon", className),
-    children: /* @__PURE__ */ jsx(
-      "path",
-      {
-        fillRule: "evenodd",
-        clipRule: "evenodd",
-        d: "M6.24388 2.4018C6.24388 2.0394 6.53767 1.74561 6.90008 1.74561H10.0991C10.4614 1.74561 10.7553 2.0394 10.7553 2.4018V4.57546C10.7553 4.93787 10.4614 5.23166 10.0991 5.23166H9.31982V7.35469L10.0033 9.22664C9.90442 9.20146 9.80035 9.1761 9.6915 9.14986L9.62652 9.13422C9.30473 9.05687 8.92256 8.96501 8.61993 8.84491C8.5819 8.82981 8.54147 8.81292 8.49957 8.79391C8.45767 8.81292 8.41724 8.82981 8.3792 8.84491C8.07657 8.96501 7.6944 9.05687 7.37261 9.13422L7.30763 9.14986C7.19879 9.1761 7.09471 9.20146 6.99577 9.22664L7.67932 7.35469V5.23166H6.90008C6.53767 5.23166 6.24388 4.93787 6.24388 4.57546V2.4018ZM6.99577 9.22664C6.99577 9.22664 6.99578 9.22664 6.99577 9.22664L6.43283 10.7683H6.81806C7.18047 10.7683 7.47426 11.0622 7.47426 11.4245V13.5982C7.47426 13.9606 7.18047 14.2544 6.81806 14.2544H3.61909C3.25668 14.2544 2.96289 13.9606 2.96289 13.5982V11.4245C2.96289 11.0622 3.25668 10.7683 3.61909 10.7683H4.26617C4.2921 10.4663 4.32783 10.1494 4.37744 9.85171C4.43762 9.49063 4.52982 9.08135 4.68998 8.76102C4.93975 8.2615 5.44743 8.01751 5.7771 7.88788C6.14684 7.74249 6.57537 7.63889 6.92317 7.55505C7.24707 7.47696 7.49576 7.41679 7.67932 7.35469L6.99577 9.22664ZM6.43283 10.7683L6.99577 9.22664C6.75846 9.28705 6.55067 9.34646 6.37745 9.41458C6.22784 9.47341 6.1623 9.51712 6.14023 9.53254C6.09752 9.63631 6.04409 9.83055 5.99562 10.1214C5.96201 10.3231 5.93498 10.5439 5.91341 10.7683H6.43283ZM10.0033 9.22664L9.31982 7.35469C9.50338 7.41679 9.75206 7.47696 10.076 7.55505C10.4238 7.63889 10.8523 7.74249 11.2221 7.88788C11.5517 8.01751 12.0594 8.2615 12.3091 8.76102C12.4693 9.08135 12.5615 9.49063 12.6217 9.85171C12.6713 10.1494 12.707 10.4663 12.733 10.7683H13.38C13.7424 10.7683 14.0362 11.0622 14.0362 11.4245V13.5982C14.0362 13.9606 13.7424 14.2544 13.38 14.2544H10.1811C9.81867 14.2544 9.52488 13.9606 9.52488 13.5982V11.4245C9.52488 11.0622 9.81867 10.7683 10.1811 10.7683H10.5663L10.0033 9.22664ZM10.0033 9.22664L10.5663 10.7683H11.0857C11.0642 10.5439 11.0372 10.3231 11.0035 10.1214C10.9551 9.83055 10.9016 9.63631 10.8589 9.53254C10.8369 9.51712 10.7713 9.47341 10.6217 9.41458C10.4485 9.34646 10.2407 9.28705 10.0033 9.22664Z",
-        fill: "currentColor"
-      }
-    )
-  }
-);
-
-const MessageClass = "mastra:flex mastra:flex-col mastra:w-full mastra:py-4 mastra:gap-2 mastra:group";
-const Message = ({ position, className, children, ...props }) => {
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: className || twMerge(
-        MessageClass,
-        position === "left" ? "" : "mastra:items-end mastra:[&_.mastra-message-content]:bg-surface4 mastra:[&_.mastra-message-content]:px-4"
-      ),
-      ...props,
-      children
-    }
-  );
+const extractTasksFromSignalChunk = (chunk) => {
+	if (!isDataChunk$1(chunk)) return void 0;
+	return extractTasksFromSignalData(chunk.data);
+};
+const extractTasksFromToolResultChunk = (chunk) => {
+	if (chunk.type !== "tool-result") return void 0;
+	const payload = chunk.payload;
+	if (!isRecord$1(payload) || typeof payload.toolName !== "string" || !TASK_TOOL_NAMES.has(payload.toolName)) return;
+	return parseTasksFromResult(payload.result);
 };
-const MessageContentClass = "mastra:max-w-4/5 mastra:py-2 mastra:text-text6 mastra:rounded-lg mastra-message-content mastra:text-md";
-const MessageContent = ({ children, className, isStreaming, ...props }) => {
-  return /* @__PURE__ */ jsxs("div", { className: className || MessageContentClass, ...props, children: [
-    children,
-    isStreaming && /* @__PURE__ */ jsx(MessageStreaming, {})
-  ] });
+const extractTasksFromToolInvocationPart = (part) => {
+	if (!isRecord$1(part) || part.type !== "tool-invocation" || !isRecord$1(part.toolInvocation)) return void 0;
+	const toolInvocation = part.toolInvocation;
+	if (typeof toolInvocation.toolName !== "string" || !TASK_TOOL_NAMES.has(toolInvocation.toolName)) return void 0;
+	return parseTasksFromResult(toolInvocation.result);
 };
-const MessageActionsClass = "mastra:gap-2 mastra:flex mastra:opacity-0 mastra:group-hover:opacity-100 mastra:group-focus-within:opacity-100 mastra:items-center";
-const MessageActions = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || MessageActionsClass, ...props, children });
+const extractTasksFromDataPart = (part) => {
+	if (!isRecord$1(part) || typeof part.type !== "string" || !part.type.startsWith("data-")) return void 0;
+	return extractTasksFromSignalData(part.data);
 };
-const MessageUsagesClass = "mastra:flex mastra:gap-2 mastra:items-center";
-const MessageUsages = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx("div", { className: className || MessageUsagesClass, ...props, children });
+const extractTasksFromSignalMessage = (message) => {
+	if (message.role !== "signal") return void 0;
+	const metadata = message.content?.metadata;
+	if (!isRecord$1(metadata)) return void 0;
+	return extractTasksFromSignalData(metadata.signal);
 };
-const MessageUsageClass = "mastra:flex mastra:gap-2 mastra:items-center mastra:font-mono mastra:text-xs mastra:bg-surface3 mastra:rounded-lg mastra:px-2 mastra:py-1";
-const MessageUsage = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx("dl", { className: className || MessageUsageClass, ...props, children });
+const extractLatestTasksFromMessages = (messages) => {
+	let latest;
+	for (const message of messages) {
+		for (const part of message.content?.parts ?? []) {
+			const toolTasks = extractTasksFromToolInvocationPart(part);
+			if (toolTasks !== void 0) latest = toolTasks;
+		}
+		const signalTasks = extractTasksFromSignalMessage(message);
+		if (signalTasks !== void 0) latest = signalTasks;
+		for (const part of message.content?.parts ?? []) {
+			const dataTasks = extractTasksFromDataPart(part);
+			if (dataTasks !== void 0) latest = dataTasks;
+		}
+	}
+	return latest ?? [];
 };
-const MessageUsageEntryClass = "mastra:text-text3 mastra:text-xs mastra:flex mastra:gap-1 mastra:items-center";
-const MessageUsageEntry = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx("dt", { className: className || MessageUsageEntryClass, ...props, children });
+//#endregion
+//#region src/agent/extractRunIdFromMessages.ts
+const isRecord = (value) => value !== null && typeof value === "object";
+const runIdMetadataKeys = [
+	"pendingToolApprovals",
+	"requireApprovalMetadata",
+	"suspendedTools"
+];
+const isRunIdMetadataSource = (value) => isRecord(value) && Object.values(value).every((entry) => isRecord(entry));
+const getRunIdMetadataSources = (metadata) => {
+	if (!isRecord(metadata)) return [];
+	const sources = [];
+	for (const key of runIdMetadataKeys) {
+		const source = metadata[key];
+		if (isRunIdMetadataSource(source)) sources.push(source);
+	}
+	return sources;
 };
-const MessageUsageValueClass = "mastra:text-text6 mastra:text-xs";
-const MessageUsageValue = ({ children, className, ...props }) => {
-  return /* @__PURE__ */ jsx("dd", { className: className || MessageUsageValueClass, ...props, children });
+/**
+* Scan initial DB-shape messages for any pending approvals, suspended tools, or
+* `requireApprovalMetadata` entries and return the first non-empty `runId`.
+*
+* Metadata is read off `message.content.metadata`, the canonical location for
+* MastraDBMessage UX hints.
+*/
+const extractRunIdFromMessages = (messages) => {
+	for (const message of messages) for (const source of getRunIdMetadataSources(message.content?.metadata)) for (const entry of Object.values(source)) if (isRecord(entry) && typeof entry.runId === "string" && entry.runId.length > 0) return entry.runId;
+};
+//#endregion
+//#region src/agent/hooks.ts
+const extractPendingToolApprovalIdsFromMessages = (messages) => {
+	const pendingToolApprovalIds = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		const metadata = message.content?.metadata;
+		if (!metadata) continue;
+		const metadataSources = [
+			metadata.pendingToolApprovals,
+			metadata.requireApprovalMetadata,
+			metadata.suspendedTools
+		];
+		for (const source of metadataSources) {
+			if (!source || typeof source !== "object") continue;
+			for (const suspensionData of Object.values(source)) {
+				const toolCallId = suspensionData?.toolCallId;
+				if (typeof toolCallId === "string" && toolCallId.length > 0) pendingToolApprovalIds.add(toolCallId);
+			}
+		}
+	}
+	return pendingToolApprovalIds;
+};
+const toolCallHasOutput = (parts, toolCallId) => parts.some((part) => {
+	if (part.type !== "tool-invocation") return false;
+	const invocation = part.toolInvocation;
+	if (invocation.toolCallId !== toolCallId) return false;
+	return invocation.state === "result" || invocation.result != null;
+});
+/**
+* Normalize persisted initial messages back into the stream-friendly shape the
+* UI renders from. Mirrors `main`'s `resolveInitialMessages`:
+*
+* - Converts persisted `pendingToolApprovals` (DB shape) into
+*   `requireApprovalMetadata` (stream shape) so reloaded threads still render
+*   approve/decline buttons, filtering out approvals whose tool already
+*   produced output, and marks the message `mode: 'stream'`.
+* - Drops assistant completion messages flagged `suppressFeedback`, which are
+*   persisted by the supervisor agent but must stay hidden on reload.
+*/
+const resolveInitialMessages = (messages) => messages.filter((message) => {
+	const metadata = message.content?.metadata;
+	if (metadata?.completionResult?.suppressFeedback || metadata?.isTaskCompleteResult?.suppressFeedback) return false;
+	return true;
+}).map((message) => {
+	const metadata = message.content?.metadata;
+	const normalizedMessage = metadata && (metadata.status === "pending" || "clientMessageId" in metadata) ? (() => {
+		const { [CLIENT_MESSAGE_ID_KEY]: _omitClientMessageId, ...rest } = metadata;
+		const { status: _omitStatus, ...restWithoutStatus } = rest;
+		return {
+			...message,
+			content: {
+				...message.content,
+				metadata: metadata.status === "pending" ? restWithoutStatus : rest
+			}
+		};
+	})() : message;
+	const normalizedMetadata = normalizedMessage.content?.metadata;
+	const pendingToolApprovals = normalizedMetadata?.pendingToolApprovals;
+	if (!pendingToolApprovals || typeof pendingToolApprovals !== "object") return normalizedMessage;
+	const stillPending = Object.fromEntries(Object.entries(pendingToolApprovals).filter(([, approval]) => approval && typeof approval === "object" && typeof approval.toolCallId === "string" && !toolCallHasOutput(normalizedMessage.content.parts, approval.toolCallId)));
+	const { pendingToolApprovals: _omit, ...restMetadata } = normalizedMetadata;
+	const hasStillPending = Object.keys(stillPending).length > 0;
+	return {
+		...normalizedMessage,
+		content: {
+			...normalizedMessage.content,
+			metadata: {
+				...restMetadata,
+				mode: "stream",
+				...hasStillPending ? {
+					pendingToolApprovals: stillPending,
+					requireApprovalMetadata: stillPending
+				} : {}
+			}
+		}
+	};
+});
+const isObject = (value) => typeof value === "object" && value !== null;
+const getErrorName = (error) => isObject(error) && typeof error.name === "string" ? error.name : void 0;
+const isAbortError = (error) => getErrorName(error) === "AbortError";
+const isThreadSignalUnsupportedError = (error) => {
+	if (!isObject(error)) return false;
+	const status = error.status;
+	if (status === 404 || status === 405 || status === 501) return true;
+	return status === 400 && typeof error.message === "string" && error.message.includes("No active agent run found for signal target");
+};
+const isDataChunk = (chunk) => typeof chunk.type === "string" && chunk.type.startsWith("data-");
+/**
+* Convert AI-SDK v5 UIMessages returned by the server (generate mode) into
+* `MastraDBMessage[]`, stamping the supplied metadata onto each message's
+* `content.metadata`. Private helper — `useChat` never exposes the AI-SDK
+* shape to consumers.
+*/
+const dbFromServerUiMessages = (uiMessages, metadata) => uiMessages.map((uiMsg) => {
+	const dbMsg = AIV5Adapter.fromUIMessage(uiMsg);
+	return {
+		...dbMsg,
+		content: {
+			...dbMsg.content,
+			metadata: {
+				...dbMsg.content.metadata ?? {},
+				...metadata
+			}
+		}
+	};
+});
+const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContext: propsRequestContext, clientTools: hookClientTools, onSignalSent, onSignalEcho, onThreadSignalsUnsupported, enableThreadSignals = false }) => {
+	const threadSignalsDisabled = enableThreadSignals === false;
+	const _currentRunId = useRef(void 0);
+	const _onChunk = useRef(void 0);
+	const _networkRunId = useRef(void 0);
+	const _onNetworkChunk = useRef(void 0);
+	const _activeContinuation = useRef({ requestContext: propsRequestContext });
+	const _streamAbortRef = useRef(null);
+	const _threadSubscriptionAbortRef = useRef(null);
+	const _threadSubscriptionRef = useRef(null);
+	const _threadSubscriptionKeyRef = useRef(void 0);
+	const _threadSubscriptionPromiseRef = useRef(null);
+	const _threadSignalsUnsupportedRef = useRef(false);
+	const [messages, setMessages] = useState([]);
+	const [tasks, setTasks] = useState([]);
+	const [toolCallApprovals, setToolCallApprovals] = useState({});
+	const [networkToolCallApprovals, setNetworkToolCallApprovals] = useState({});
+	const pendingToolApprovalIdsRef = useRef(/* @__PURE__ */ new Set());
+	const [isAwaitingToolApproval, setIsAwaitingToolApproval] = useState(false);
+	const baseClient = useMastraClient();
+	const [isRunning, setIsRunning] = useState(false);
+	useEffect(() => {
+		const formattedMessages = resolveInitialMessages(initialMessages ?? []);
+		setMessages(formattedMessages);
+		setTasks(extractLatestTasksFromMessages(formattedMessages));
+		pendingToolApprovalIdsRef.current = extractPendingToolApprovalIdsFromMessages(formattedMessages);
+		setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+		_currentRunId.current = extractRunIdFromMessages(formattedMessages);
+	}, [initialMessages]);
+	useEffect(() => {
+		_activeContinuation.current = {
+			..._activeContinuation.current,
+			requestContext: propsRequestContext
+		};
+	}, [propsRequestContext]);
+	const normalizeSignalFileData = (data) => {
+		if (data instanceof URL) return data.toString();
+		return convertSignalDataToBase64String(data);
+	};
+	const getSignalContents = (coreUserMessages) => {
+		const parts = coreUserMessages.reduce((allParts, message) => {
+			if (typeof message.content === "string") {
+				allParts.push({
+					type: "text",
+					text: message.content
+				});
+				return allParts;
+			}
+			for (const part of message.content) if (part.type === "text") allParts.push({
+				type: "text",
+				text: part.text
+			});
+			else if (part.type === "file") allParts.push({
+				type: "file",
+				data: normalizeSignalFileData(part.data),
+				mediaType: part.mimeType,
+				...part.filename ? { filename: part.filename } : {}
+			});
+			else if (part.type === "image") allParts.push({
+				type: "file",
+				data: normalizeSignalFileData(part.image),
+				mediaType: part.mimeType ?? "image/png"
+			});
+			return allParts;
+		}, []);
+		return parts.length === 1 && parts[0]?.type === "text" ? parts[0].text : parts;
+	};
+	const markThreadSignalsUnsupported = useCallback(() => {
+		_threadSignalsUnsupportedRef.current = true;
+		onThreadSignalsUnsupported?.();
+	}, [onThreadSignalsUnsupported]);
+	const getSignalPreview = (coreUserMessages) => {
+		return coreUserMessages.flatMap((message) => {
+			if (typeof message.content === "string") return [message.content];
+			return message.content.map((part) => {
+				if (part.type === "text") return part.text;
+				if (part.type === "image") return "Image";
+				return part.filename ? `File: ${part.filename}` : "File";
+			});
+		}).join(" ").replace(/\s+/g, " ").trim() || "Attachment";
+	};
+	const closeThreadSubscription = useCallback(() => {
+		const subscription = _threadSubscriptionRef.current;
+		if (subscription?.unsubscribe) subscription.unsubscribe();
+		else _threadSubscriptionAbortRef.current?.abort();
+		_threadSubscriptionRef.current = null;
+		_threadSubscriptionAbortRef.current = null;
+		_threadSubscriptionKeyRef.current = void 0;
+		_threadSubscriptionPromiseRef.current = null;
+	}, []);
+	const processStreamChunk = useCallback(async (chunk, onChunk) => {
+		setMessages((prev) => accumulateChunk({
+			chunk,
+			conversation: prev,
+			metadata: { mode: "stream" }
+		}));
+		const signalTasks = extractTasksFromSignalChunk(chunk);
+		if (signalTasks !== void 0) setTasks(signalTasks);
+		const toolTasks = extractTasksFromToolResultChunk(chunk);
+		if (toolTasks !== void 0) setTasks(toolTasks);
+		if (chunk.type === "data-user-message" && isDataChunk(chunk) && (chunk.data?.type === "user-message" || chunk.data?.type === "user") && typeof chunk.data?.id === "string") onSignalEcho?.(chunk.data.id);
+		if (chunk.type === "start") {
+			setIsRunning(true);
+			if ("runId" in chunk && typeof chunk.runId === "string") _currentRunId.current = chunk.runId;
+		}
+		if (chunk.type === "tool-call-approval" || chunk.type === "tool-call-suspended") {
+			const toolCallId = chunk.payload?.toolCallId;
+			if (typeof toolCallId === "string") {
+				pendingToolApprovalIdsRef.current.add(toolCallId);
+				setIsAwaitingToolApproval(true);
+			}
+			setIsRunning(false);
+		}
+		if (chunk.type === "finish" || chunk.type === "abort" || chunk.type === "error") {
+			pendingToolApprovalIdsRef.current.clear();
+			setIsAwaitingToolApproval(false);
+			setIsRunning(false);
+		}
+		(onChunk ?? _onChunk.current)?.(chunk);
+	}, [onSignalEcho]);
+	const ensureThreadSubscription = useCallback(async ({ threadId, resourceId }) => {
+		const subscriptionKey = `${agentId}:${resourceId ?? ""}:${threadId}`;
+		if (_threadSubscriptionKeyRef.current === subscriptionKey && _threadSubscriptionPromiseRef.current) {
+			await _threadSubscriptionPromiseRef.current;
+			return;
+		}
+		closeThreadSubscription();
+		const subscriptionAbort = new AbortController();
+		_threadSubscriptionAbortRef.current = subscriptionAbort;
+		_threadSubscriptionKeyRef.current = subscriptionKey;
+		const releaseSubscriptionRefs = () => {
+			if (_threadSubscriptionAbortRef.current !== subscriptionAbort) return;
+			_threadSubscriptionRef.current = null;
+			_threadSubscriptionAbortRef.current = null;
+			_threadSubscriptionKeyRef.current = void 0;
+			_threadSubscriptionPromiseRef.current = null;
+		};
+		const subscriptionAgent = new MastraClient({
+			...baseClient.options,
+			abortSignal: subscriptionAbort.signal
+		}).getAgent(agentId);
+		_threadSubscriptionPromiseRef.current = subscriptionAgent.subscribeToThread({
+			resourceId,
+			threadId
+		}).then((response) => {
+			const subscription = response;
+			if (_threadSubscriptionAbortRef.current !== subscriptionAbort) {
+				subscription.unsubscribe();
+				return;
+			}
+			_threadSubscriptionRef.current = subscription;
+			subscription.processDataStream({ onChunk: (chunk) => processStreamChunk(chunk) }).catch((error) => {
+				if (!isAbortError(error)) {
+					console.error("[useChat] Thread subscription failed", error);
+					setIsRunning(false);
+				}
+			}).finally(() => {
+				if (_threadSubscriptionRef.current === subscription) _threadSubscriptionRef.current = null;
+				releaseSubscriptionRefs();
+			});
+		}).catch((error) => {
+			releaseSubscriptionRefs();
+			if (isThreadSignalUnsupportedError(error)) {
+				markThreadSignalsUnsupported();
+				return;
+			}
+			if (!isAbortError(error)) {
+				console.error("[useChat] Thread subscription failed", error);
+				setIsRunning(false);
+			}
+			throw error;
+		});
+		await _threadSubscriptionPromiseRef.current;
+	}, [
+		agentId,
+		baseClient,
+		closeThreadSubscription,
+		markThreadSignalsUnsupported,
+		processStreamChunk
+	]);
+	useEffect(() => {
+		_threadSignalsUnsupportedRef.current = false;
+		return closeThreadSubscription;
+	}, [
+		agentId,
+		resourceId,
+		threadId,
+		closeThreadSubscription
+	]);
+	useEffect(() => {
+		if (!threadId || threadSignalsDisabled) {
+			closeThreadSubscription();
+			return;
+		}
+		ensureThreadSubscription({
+			threadId,
+			resourceId: resourceId || agentId
+		}).catch((error) => {
+			if (!isAbortError(error)) console.error("[useChat] Thread subscription failed", error);
+		});
+	}, [
+		agentId,
+		closeThreadSubscription,
+		ensureThreadSubscription,
+		resourceId,
+		threadId,
+		threadSignalsDisabled
+	]);
+	const generate = async ({ coreUserMessages, model, requestContext, threadId, modelSettings, signal, onFinish, tracingOptions, clientTools }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, instructions, providerOptions, maxSteps, requireToolApproval } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		const resolvedClientTools = clientTools ?? hookClientTools;
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: signal
+		}).getAgent(agentId);
+		const runId = v4();
+		_currentRunId.current = runId;
+		const response = await agent.generate(coreUserMessages, {
+			model,
+			runId,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			requestContext: resolvedRequestContext,
+			...threadId ? { memory: {
+				thread: threadId,
+				resource: resourceId || agentId
+			} } : {},
+			providerOptions,
+			tracingOptions,
+			requireToolApproval,
+			clientTools: resolvedClientTools
+		});
+		if (response.finishReason === "suspended" && response.suspendPayload) {
+			const { toolCallId, toolName, args } = response.suspendPayload;
+			if (response.response?.uiMessages) {
+				const dbMessages = dbFromServerUiMessages(response.response.uiMessages, {
+					mode: "generate",
+					requireApprovalMetadata: { [toolName]: {
+						toolCallId,
+						toolName,
+						args
+					} }
+				});
+				setMessages((prev) => [...prev, ...dbMessages]);
+			}
+			setIsRunning(false);
+			return;
+		}
+		setIsRunning(false);
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			onFinish?.(dbMessages);
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+	};
+	const stream = async ({ coreUserMessages, model, requestContext, threadId, onChunk, modelSettings, signal, tracingOptions, clientTools, signalId, clientMessageId }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, instructions, providerOptions, maxSteps, requireToolApproval } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		const resolvedClientTools = clientTools ?? hookClientTools;
+		const signalContinuationOptions = {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			providerOptions,
+			requireToolApproval,
+			tracingOptions
+		};
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		_streamAbortRef.current?.abort();
+		const internalAbort = new AbortController();
+		_streamAbortRef.current = internalAbort;
+		if (signal) if (signal.aborted) internalAbort.abort();
+		else signal.addEventListener("abort", () => internalAbort.abort(), { once: true });
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: internalAbort.signal
+		}).getAgent(agentId);
+		const streamWithLegacyRoute = async () => {
+			const runId = v4();
+			const response = await agent.stream(coreUserMessages, {
+				model,
+				runId,
+				maxSteps,
+				untilIdle: true,
+				modelSettings: {
+					frequencyPenalty,
+					presencePenalty,
+					maxRetries,
+					maxOutputTokens: maxTokens,
+					temperature,
+					topK,
+					topP
+				},
+				instructions,
+				requestContext: resolvedRequestContext,
+				...threadId ? { memory: {
+					thread: threadId,
+					resource: resourceId || agentId
+				} } : {},
+				providerOptions,
+				requireToolApproval,
+				tracingOptions,
+				clientTools: resolvedClientTools
+			});
+			_onChunk.current = onChunk;
+			_currentRunId.current = runId;
+			await response.processDataStream({ onChunk: (chunk) => processStreamChunk(chunk, onChunk) });
+			if (_streamAbortRef.current === internalAbort) _streamAbortRef.current = null;
+			setIsRunning(false);
+		};
+		if (!threadId || _threadSignalsUnsupportedRef.current || threadSignalsDisabled) {
+			await streamWithLegacyRoute();
+			return;
+		}
+		_onChunk.current = onChunk;
+		await ensureThreadSubscription({
+			threadId,
+			resourceId: resourceId || agentId
+		});
+		if (_threadSignalsUnsupportedRef.current) {
+			await streamWithLegacyRoute();
+			return;
+		}
+		const resolvedSignalId = signalId ?? v4();
+		const messageContents = getSignalContents(coreUserMessages);
+		const requestContextRecord = resolvedRequestContext;
+		const streamOptions = {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			requestContext: requestContextRecord,
+			providerOptions,
+			requireToolApproval,
+			tracingOptions
+		};
+		try {
+			const result = await agent.sendMessage({
+				message: clientMessageId ? {
+					contents: messageContents,
+					metadata: { [CLIENT_MESSAGE_ID_KEY]: clientMessageId }
+				} : messageContents,
+				resourceId: resourceId || agentId,
+				threadId,
+				ifIdle: { streamOptions: {
+					...signalContinuationOptions,
+					requestContext: requestContextRecord,
+					clientTools: resolvedClientTools
+				} }
+			});
+			const echoedSignalId = result.signal && typeof result.signal === "object" && "id" in result.signal && typeof result.signal.id === "string" ? result.signal.id : resolvedSignalId;
+			onSignalSent?.(echoedSignalId, getSignalPreview(coreUserMessages));
+			if (pendingToolApprovalIdsRef.current.size > 0) setIsRunning(false);
+		} catch (error) {
+			if (isThreadSignalUnsupportedError(error)) {
+				onSignalSent?.(resolvedSignalId, getSignalPreview(coreUserMessages));
+				try {
+					await agent.sendSignal({
+						signal: {
+							id: resolvedSignalId,
+							type: "user-message",
+							contents: messageContents
+						},
+						resourceId: resourceId || agentId,
+						threadId,
+						ifIdle: { streamOptions }
+					});
+					return;
+				} catch (signalError) {
+					onSignalEcho?.(resolvedSignalId);
+					if (isThreadSignalUnsupportedError(signalError)) {
+						markThreadSignalsUnsupported();
+						setMessages((prev) => [...prev, fromCoreUserMessagesToMastraDBMessage(coreUserMessages)]);
+						await streamWithLegacyRoute();
+						return;
+					}
+					throw signalError;
+				}
+			}
+			throw error;
+		}
+		if (_streamAbortRef.current === internalAbort) _streamAbortRef.current = null;
+	};
+	const network = async ({ coreUserMessages, model, requestContext, threadId, onNetworkChunk, modelSettings, signal, tracingOptions }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: signal
+		}).getAgent(agentId);
+		const runId = v4();
+		const response = await agent.network(coreUserMessages, {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			runId,
+			requestContext: resolvedRequestContext,
+			...threadId ? { memory: {
+				thread: threadId,
+				resource: resourceId || agentId
+			} } : {},
+			tracingOptions
+		});
+		_onNetworkChunk.current = onNetworkChunk;
+		_networkRunId.current = runId;
+		await response.processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: { mode: "network" }
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const handleCancelRun = () => {
+		_streamAbortRef.current?.abort();
+		_streamAbortRef.current = null;
+		const threadSubscription = _threadSubscriptionRef.current;
+		Promise.resolve(threadSubscription?.abort?.()).catch((error) => {
+			console.error("[useChat] Failed to abort thread subscription", error);
+		});
+		closeThreadSubscription();
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		pendingToolApprovalIdsRef.current.clear();
+		setIsAwaitingToolApproval(false);
+		setIsRunning(false);
+		_currentRunId.current = void 0;
+		_onChunk.current = void 0;
+		_networkRunId.current = void 0;
+		_onNetworkChunk.current = void 0;
+		_activeContinuation.current = {};
+	};
+	const approveToolCall = async (toolCallId, resumeData) => {
+		const onChunk = _onChunk.current;
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[approveToolCall] approveToolCall can only be called after a stream has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "approved" }
+		}));
+		const agent = baseClient.getAgent(agentId);
+		if (_threadSubscriptionKeyRef.current && threadId) {
+			try {
+				await agent.sendToolApproval({
+					resourceId: resourceId || agentId,
+					threadId,
+					toolCallId,
+					approved: true,
+					...continuation.model !== void 0 ? { streamOptions: { model: continuation.model } } : {},
+					...resumeData !== void 0 ? { resumeData } : {},
+					requestContext: continuation.requestContext
+				});
+				pendingToolApprovalIdsRef.current.delete(toolCallId);
+				setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+				setIsRunning(false);
+			} catch (error) {
+				setToolCallApprovals((prev) => {
+					const next = { ...prev };
+					delete next[toolCallId];
+					return next;
+				});
+				setIsRunning(false);
+				throw error;
+			}
+			return;
+		}
+		await (await agent.approveToolCall({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			await processStreamChunk(chunk, onChunk);
+		} });
+		setIsRunning(false);
+	};
+	const declineToolCall = async (toolCallId) => {
+		const onChunk = _onChunk.current;
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[declineToolCall] declineToolCall can only be called after a stream has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "declined" }
+		}));
+		const agent = baseClient.getAgent(agentId);
+		if (_threadSubscriptionKeyRef.current && threadId) {
+			try {
+				await agent.sendToolApproval({
+					resourceId: resourceId || agentId,
+					threadId,
+					toolCallId,
+					approved: false,
+					...continuation.model !== void 0 ? { streamOptions: { model: continuation.model } } : {},
+					requestContext: continuation.requestContext
+				});
+				pendingToolApprovalIdsRef.current.delete(toolCallId);
+				setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+				setIsRunning(false);
+			} catch (error) {
+				setToolCallApprovals((prev) => {
+					const next = { ...prev };
+					delete next[toolCallId];
+					return next;
+				});
+				setIsRunning(false);
+				throw error;
+			}
+			return;
+		}
+		await (await agent.declineToolCall({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			await processStreamChunk(chunk, onChunk);
+		} });
+		setIsRunning(false);
+	};
+	const approveToolCallGenerate = async (toolCallId) => {
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[approveToolCallGenerate] approveToolCallGenerate can only be called after a generate has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "approved" }
+		}));
+		const response = await baseClient.getAgent(agentId).approveToolCallGenerate({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		});
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+		setIsRunning(false);
+	};
+	const declineToolCallGenerate = async (toolCallId) => {
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[declineToolCallGenerate] declineToolCallGenerate can only be called after a generate has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "declined" }
+		}));
+		const response = await baseClient.getAgent(agentId).declineToolCallGenerate({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		});
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+		setIsRunning(false);
+	};
+	const approveNetworkToolCall = async (toolName, runId) => {
+		const onNetworkChunk = _onNetworkChunk.current;
+		const networkRunId = runId || _networkRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!networkRunId) return console.info("[approveNetworkToolCall] approveNetworkToolCall can only be called after a network stream has started");
+		setIsRunning(true);
+		setNetworkToolCallApprovals((prev) => ({
+			...prev,
+			[runId ? `${runId}-${toolName}` : toolName]: { status: "approved" }
+		}));
+		await (await baseClient.getAgent(agentId).approveNetworkToolCall({
+			runId: networkRunId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: { mode: "network" }
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const declineNetworkToolCall = async (toolName, runId) => {
+		const onNetworkChunk = _onNetworkChunk.current;
+		const networkRunId = runId || _networkRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!networkRunId) return console.info("[declineNetworkToolCall] declineNetworkToolCall can only be called after a network stream has started");
+		setIsRunning(true);
+		setNetworkToolCallApprovals((prev) => ({
+			...prev,
+			[runId ? `${runId}-${toolName}` : toolName]: { status: "declined" }
+		}));
+		await (await baseClient.getAgent(agentId).declineNetworkToolCall({
+			runId: networkRunId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: { mode: "network" }
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const sendMessage = async ({ mode = "stream", ...args }) => {
+		const coreUserMessages = [{
+			role: "user",
+			content: [{
+				type: "text",
+				text: args.message
+			}]
+		}];
+		if (args.coreUserMessages) coreUserMessages.push(...args.coreUserMessages);
+		const dbUserMessage = fromCoreUserMessagesToMastraDBMessage(coreUserMessages);
+		const clientSetId = mode === "stream" && args.threadId && !_threadSignalsUnsupportedRef.current && !threadSignalsDisabled ? `client-set-${v4()}` : void 0;
+		const signalId = clientSetId;
+		const clientMessageId = clientSetId;
+		if (signalId) {
+			const metadata = {
+				...dbUserMessage.content.metadata,
+				mode: "stream",
+				status: "pending",
+				[CLIENT_MESSAGE_ID_KEY]: clientMessageId
+			};
+			const pendingMessage = {
+				...dbUserMessage,
+				id: clientSetId,
+				content: {
+					...dbUserMessage.content,
+					metadata
+				}
+			};
+			setMessages((s) => [...s, pendingMessage]);
+		} else setMessages((s) => [...s, dbUserMessage]);
+		try {
+			if (mode === "generate") await generate({
+				...args,
+				coreUserMessages
+			});
+			else if (mode === "stream") await stream({
+				...args,
+				coreUserMessages,
+				signalId,
+				clientMessageId
+			});
+			else if (mode === "network") await network({
+				...args,
+				coreUserMessages
+			});
+		} catch (error) {
+			setIsRunning(false);
+			throw error;
+		}
+	};
+	return {
+		setMessages,
+		sendMessage,
+		isRunning,
+		isAwaitingToolApproval,
+		messages,
+		tasks,
+		approveToolCall,
+		declineToolCall,
+		approveToolCallGenerate,
+		declineToolCallGenerate,
+		cancelRun: handleCancelRun,
+		toolCallApprovals,
+		approveNetworkToolCall,
+		declineNetworkToolCall,
+		networkToolCallApprovals
+	};
+};
+//#endregion
+//#region src/lib/use-mutation.ts
+/**
+* Internal helper hook that provides mutation-like functionality without react-query.
+* Tracks pending, success, and error states for async operations.
+*/
+function useMutation(mutationFn) {
+	const [isPending, setIsPending] = useState(false);
+	const [isSuccess, setIsSuccess] = useState(false);
+	const [isError, setIsError] = useState(false);
+	const [error, setError] = useState(null);
+	const [data, setData] = useState(void 0);
+	const mutationFnRef = useRef(mutationFn);
+	mutationFnRef.current = mutationFn;
+	const reset = useCallback(() => {
+		setIsPending(false);
+		setIsSuccess(false);
+		setIsError(false);
+		setError(null);
+		setData(void 0);
+	}, []);
+	const mutateAsync = useCallback(async (variables) => {
+		setIsPending(true);
+		setIsSuccess(false);
+		setIsError(false);
+		setError(null);
+		try {
+			const result = await mutationFnRef.current(variables);
+			setData(result);
+			setIsSuccess(true);
+			return result;
+		} catch (err) {
+			setError(err);
+			setIsError(true);
+			throw err;
+		} finally {
+			setIsPending(false);
+		}
+	}, []);
+	return {
+		mutate: useCallback((variables) => {
+			mutateAsync(variables).catch(() => {});
+		}, [mutateAsync]),
+		mutateAsync,
+		isPending,
+		isSuccess,
+		isError,
+		error,
+		data,
+		reset
+	};
+}
+//#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 [isStreaming, setIsStreaming] = useState(false);
+	const readerRef = useRef(null);
+	const observerRef = useRef(null);
+	const resumeStreamRef = useRef(null);
+	const timeTravelStreamRef = useRef(null);
+	const isMountedRef = useRef(true);
+	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;
+			}
+		};
+	}, []);
+	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();
+		if (!isMountedRef.current) return;
+		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 { 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 streaming workflow");
+		} finally {
+			if (isMountedRef.current) setIsStreaming(false);
+			if (readerRef.current) {
+				readerRef.current.releaseLock();
+				readerRef.current = null;
+			}
+		}
+	});
+	const observeWorkflowStream = useMutation(async ({ workflowId, runId, storeRunResult }) => {
+		if (observerRef.current) observerRef.current.releaseLock();
+		if (!isMountedRef.current) return;
+		setIsStreaming(true);
+		setStreamResult(storeRunResult || {});
+		if (storeRunResult?.status === "suspended") {
+			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;
+			}
+		}
+	});
+	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({
+			step,
+			resumeData,
+			requestContext: playgroundRequestContext,
+			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({
+			...params,
+			perStep: perStep ?? debugMode,
+			requestContext: playgroundRequestContext,
+			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;
+			}
+		}
+	});
+	return {
+		streamWorkflow,
+		streamResult,
+		isStreaming,
+		observeWorkflowStream,
+		closeStreamsAndReset: useCallback(() => {
+			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;
+			}
+		}, []),
+		resumeWorkflowStream,
+		timeTravelWorkflowStream
+	};
+}
+//#endregion
+//#region src/workflows/hooks.ts
+/**
+* Hook for creating workflow runs.
+* Returns a mutation for creating a new workflow run.
+*
+* @example
+* ```tsx
+* const createWorkflowRun = useCreateWorkflowRun();
+*
+* // Create a run
+* const { runId } = await createWorkflowRun.mutateAsync({
+*   workflowId: 'my-workflow'
+* });
+* ```
+*/
+function useCreateWorkflowRun() {
+	const client = useMastraClient();
+	return useMutation(async ({ workflowId, prevRunId }) => {
+		try {
+			const { runId: newRunId } = await client.getWorkflow(workflowId).createRun({ runId: prevRunId });
+			return { runId: newRunId };
+		} catch (error) {
+			console.error("Error creating workflow run:", error);
+			throw error;
+		}
+	});
+}
+/**
+* Hook for canceling workflow runs.
+* Returns a mutation for canceling a running workflow.
+*
+* @example
+* ```tsx
+* const cancelWorkflowRun = useCancelWorkflowRun();
+*
+* // Cancel a run
+* await cancelWorkflowRun.mutateAsync({
+*   workflowId: 'my-workflow',
+*   runId: 'run-123'
+* });
+* ```
+*/
+function useCancelWorkflowRun() {
+	const client = useMastraClient();
+	return useMutation(async ({ workflowId, runId }) => {
+		try {
+			return (await client.getWorkflow(workflowId).createRun({ runId })).cancelRun();
+		} catch (error) {
+			console.error("Error canceling workflow run:", error);
+			throw error;
+		}
+	});
+}
+//#endregion
+//#region src/workflows/WorkflowStepFactory/WorkflowStepFactory.tsx
+const renderUnknown = (step, UnknownStep) => UnknownStep?.(step) ?? null;
+const WorkflowStepFactoryComponent = ({ step, Step, MapStep, AgentStep, ToolStep, ForEachStep, ParallelStep, Conditional, LoopStep, SleepStep, SleepUntilStep, NestedWorkflowStep, UnknownStep }) => {
+	switch (step.kind) {
+		case "step": return /* @__PURE__ */ jsx(Fragment$1, { children: Step?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "map-step": return /* @__PURE__ */ jsx(Fragment$1, { children: MapStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "agent-step": return /* @__PURE__ */ jsx(Fragment$1, { children: AgentStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "tool-step": return /* @__PURE__ */ jsx(Fragment$1, { children: ToolStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "foreach-step": return /* @__PURE__ */ jsx(Fragment$1, { children: ForEachStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "parallel-step": return /* @__PURE__ */ jsx(Fragment$1, { children: ParallelStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "conditional": return /* @__PURE__ */ jsx(Fragment$1, { children: Conditional?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "loop-step": return /* @__PURE__ */ jsx(Fragment$1, { children: LoopStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "sleep-step": return /* @__PURE__ */ jsx(Fragment$1, { children: SleepStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "sleep-until-step": return /* @__PURE__ */ jsx(Fragment$1, { children: SleepUntilStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		case "nested-workflow-step": return /* @__PURE__ */ jsx(Fragment$1, { children: NestedWorkflowStep?.(step) ?? renderUnknown(step, UnknownStep) });
+		default: return /* @__PURE__ */ jsx(Fragment$1, { children: renderUnknown(step, UnknownStep) });
+	}
+};
+const WorkflowStepFactory = memo(WorkflowStepFactoryComponent);
+//#endregion
+//#region src/voice/record-mic-to-file.ts
+async function recordMicrophoneToFile(onFinish) {
+	const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+	const mediaRecorder = new MediaRecorder(stream);
+	let chunks = [];
+	mediaRecorder.ondataavailable = (e) => {
+		chunks.push(e.data);
+	};
+	mediaRecorder.onstop = () => {
+		const blob = new Blob(chunks, { type: "audio/webm" });
+		const file = new File([blob], `recording-${Date.now()}.webm`, {
+			type: "audio/webm",
+			lastModified: Date.now()
+		});
+		stream.getTracks().forEach((track) => track.stop());
+		onFinish(file);
+	};
+	return mediaRecorder;
+}
+//#endregion
+//#region src/voice/play-stream-with-web-audio.ts
+async function playStreamWithWebAudio(stream, onEnded) {
+	const audioContext = new window.AudioContext();
+	const reader = stream.getReader();
+	const chunks = [];
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+		}
+		const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+		const combinedBuffer = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const chunk of chunks) {
+			combinedBuffer.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const audioBuffer = await audioContext.decodeAudioData(combinedBuffer.buffer);
+		const source = audioContext.createBufferSource();
+		source.buffer = audioBuffer;
+		source.onended = onEnded ?? null;
+		source.connect(audioContext.destination);
+		source.start();
+		return () => {
+			source.onended = null;
+			source.stop();
+			audioContext.close();
+		};
+	} catch (error) {
+		await reader.cancel().catch(() => void 0);
+		await audioContext.close().catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region src/voice/use-speech-recognition.ts
+const useSpeechRecognition = ({ language = "en-US", agentId, requestContext }) => {
+	const client = useMastraClient();
+	const [agent, setAgent] = useState(null);
+	useEffect(() => {
+		let cancelled = false;
+		if (!agentId) {
+			setAgent(null);
+			return () => {
+				cancelled = true;
+			};
+		}
+		const agent = client.getAgent(agentId);
+		const check = async () => {
+			try {
+				const speakers = await agent.voice.getSpeakers(requestContext);
+				if (!cancelled) setAgent(speakers.length > 0 ? agent : null);
+			} catch {
+				if (!cancelled) setAgent(null);
+			}
+		};
+		check();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		agentId,
+		client,
+		requestContext
+	]);
+	const browserSpeechRecognition = useBrowserSpeechRecognition({ language });
+	const mastraSpeechRecognition = useMastraSpeechToText({
+		agent,
+		language
+	});
+	if (!agent) return browserSpeechRecognition;
+	return mastraSpeechRecognition;
 };
-const MessageListClass = "mastra:overflow-y-auto mastra:h-full mastra-list";
-const MessageList = ({ children, className, ...props }) => {
-  const listRef = useRef(null);
-  useEffect(() => {
-    const scrollToBottom = () => {
-      if (!listRef.current) return;
-      listRef.current.scrollTo({ top: listRef.current.scrollHeight, behavior: "smooth" });
-    };
-    requestAnimationFrame(scrollToBottom);
-  });
-  return /* @__PURE__ */ jsx("div", { className: className || MessageListClass, ...props, ref: listRef, children });
+const useBrowserSpeechRecognition = ({ language = "en-US" }) => {
+	const speechRecognitionRef = useRef(null);
+	const [state, setState] = useState({
+		isListening: false,
+		transcript: "",
+		error: null
+	});
+	const start = () => {
+		if (!speechRecognitionRef.current) return;
+		speechRecognitionRef.current.start();
+	};
+	const stop = () => {
+		if (!speechRecognitionRef.current) return;
+		speechRecognitionRef.current.stop();
+	};
+	useEffect(() => {
+		if (!("webkitSpeechRecognition" in window) && !("SpeechRecognition" in window)) {
+			setState((prev) => ({
+				...prev,
+				error: "Speech Recognition not supported in this browser"
+			}));
+			return;
+		}
+		const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+		speechRecognitionRef.current = recognition;
+		recognition.continuous = true;
+		recognition.lang = language;
+		recognition.onstart = () => {
+			setState((prev) => ({
+				...prev,
+				isListening: true,
+				error: null
+			}));
+		};
+		recognition.onresult = (event) => {
+			let finalTranscript = "";
+			for (let i = event.resultIndex; i < event.results.length; i++) {
+				const transcript = event.results[i][0].transcript;
+				if (event.results[i].isFinal) finalTranscript += transcript + " ";
+			}
+			setState((prev) => ({
+				...prev,
+				transcript: finalTranscript
+			}));
+		};
+		recognition.onerror = (event) => {
+			setState((prev) => ({
+				...prev,
+				error: `Error: ${event.error}`
+			}));
+		};
+		recognition.onend = () => setState((prev) => ({
+			...prev,
+			isListening: false
+		}));
+		return () => {
+			try {
+				recognition.stop();
+			} catch {}
+			recognition.onstart = null;
+			recognition.onresult = null;
+			recognition.onerror = null;
+			recognition.onend = null;
+			speechRecognitionRef.current = null;
+		};
+	}, [language]);
+	return {
+		...state,
+		start,
+		stop
+	};
 };
-const MessageStreamingClass = "mastra:inline-block mastra:w-[2px] mastra:h-[1em] mastra:bg-text5 mastra:ml-0.5 mastra:align-text-bottom mastra:animate-pulse";
-const MessageStreaming = ({ className, ...props }) => {
-  return /* @__PURE__ */ jsx("span", { className: className || MessageStreamingClass, ...props });
+const useMastraSpeechToText = ({ agent, language }) => {
+	const [state, setState] = useState({
+		isListening: false,
+		transcript: "",
+		error: null
+	});
+	const recorderRef = useRef(null);
+	const sessionRef = useRef(0);
+	const startInFlightRef = useRef(false);
+	useEffect(() => {
+		return () => {
+			sessionRef.current += 1;
+			startInFlightRef.current = false;
+			recorderRef.current?.stop();
+			recorderRef.current = null;
+		};
+	}, [agent]);
+	const handleFinish = (session) => (file) => {
+		if (!agent || session !== sessionRef.current) return;
+		recorderRef.current = null;
+		setState((prev) => ({
+			...prev,
+			isListening: false
+		}));
+		agent.voice.listen(file, { language }).then((res) => {
+			if (session !== sessionRef.current) return;
+			setState((prev) => ({
+				...prev,
+				transcript: res.text,
+				error: null
+			}));
+		}).catch((error) => {
+			if (session !== sessionRef.current) return;
+			const message = error instanceof Error ? error.message : "Failed to transcribe speech";
+			setState((prev) => ({
+				...prev,
+				error: message
+			}));
+		});
+	};
+	const start = () => {
+		if (!agent || startInFlightRef.current || recorderRef.current) return;
+		startInFlightRef.current = true;
+		sessionRef.current += 1;
+		const session = sessionRef.current;
+		recordMicrophoneToFile(handleFinish(session)).then((recorder) => {
+			startInFlightRef.current = false;
+			if (session !== sessionRef.current) {
+				try {
+					recorder.stop();
+				} catch {}
+				return;
+			}
+			recorderRef.current = recorder;
+			setState((prev) => ({
+				...prev,
+				isListening: true,
+				error: null
+			}));
+			recorder.start();
+		}).catch((error) => {
+			startInFlightRef.current = false;
+			if (session !== sessionRef.current) return;
+			const message = error instanceof Error ? error.message : "Failed to start speech recording";
+			setState((prev) => ({
+				...prev,
+				isListening: false,
+				error: message
+			}));
+		});
+	};
+	const stop = () => {
+		if (recorderRef.current) {
+			recorderRef.current.stop();
+			recorderRef.current = null;
+		} else if (startInFlightRef.current) sessionRef.current += 1;
+		startInFlightRef.current = false;
+		setState((prev) => ({
+			...prev,
+			isListening: false
+		}));
+	};
+	return {
+		...state,
+		start,
+		stop
+	};
 };
+//#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 { AgentIcon, 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, 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, mapWorkflowStreamChunkToWatchResult, toAssistantUIMessage, toUIMessage, useChat, useEntity, useMastraClient };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map