@mastra/react 0.2.7 → 0.2.8-alpha.0

package/dist/index.cjs

@@ -1,73 +1,2771 @@
 'use strict';
 
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+var clientJs = require('@mastra/client-js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var uuid = require('@lukeed/uuid');
+var loop = require('@mastra/core/loop');
+var lucideReact = require('lucide-react');
+var tailwindMerge = require('tailwind-merge');
+var reactTooltip = require('@radix-ui/react-tooltip');
+var hastUtilToJsxRuntime = require('hast-util-to-jsx-runtime');
+var web = require('shiki/bundle/web');
+var requestContext = require('@mastra/core/request-context');
 
-const index = require('./index-DlzF_2Lc.cjs');
+// src/mastra-client-context.tsx
+var MastraClientContext = react.createContext({});
+var MastraClientProvider = ({ children, baseUrl, headers, apiPrefix }) => {
+  const client = createMastraClient(baseUrl, headers, apiPrefix);
+  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientContext.Provider, { value: client, children });
+};
+var useMastraClient = () => react.useContext(MastraClientContext);
+var IPV4_LOOPBACK_RE = /^127\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+var isIPv4Loopback = (hostname) => {
+  const m = IPV4_LOOPBACK_RE.exec(hostname);
+  if (!m) return false;
+  return +m[1] <= 255 && +m[2] <= 255 && +m[3] <= 255;
+};
+var 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;
+  }
+};
+var createMastraClient = (baseUrl, mastraClientHeaders = {}, apiPrefix) => {
+  return new clientJs.MastraClient({
+    baseUrl: baseUrl || "",
+    headers: isLocalUrl(baseUrl) ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders,
+    apiPrefix
+  });
+};
+var MastraReactProvider = ({ children, baseUrl, headers, apiPrefix }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, apiPrefix, children });
+};
+var 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, 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") {
+    const progressSteps = {
+      ...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
+        }
+      }
+    };
+    return {
+      ...prev,
+      steps: progressSteps
+    };
+  }
+  if (chunk.type === "workflow-step-result") {
+    return {
+      ...prev,
+      steps: newSteps
+    };
+  }
+  return prev;
+};
+var toUIMessage = ({ chunk, conversation, metadata }) => {
+  const result = [...conversation];
+  if (chunk.type.startsWith("data-")) {
+    const lastMessage = result[result.length - 1];
+    if (!lastMessage || lastMessage.role !== "assistant") {
+      const newMessage = {
+        id: `data-${chunk.runId}-${Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: chunk.type,
+            data: "data" in chunk ? chunk.data : void 0
+          }
+        ],
+        metadata
+      };
+      return [...result, newMessage];
+    }
+    const updatedMessage = {
+      ...lastMessage,
+      parts: [
+        ...lastMessage.parts,
+        {
+          type: chunk.type,
+          data: "data" in chunk ? chunk.data : void 0
+        }
+      ]
+    };
+    return [...result.slice(0, -1), updatedMessage];
+  }
+  switch (chunk.type) {
+    case "tripwire": {
+      const newMessage = {
+        id: `tripwire-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: chunk.payload.reason
+          }
+        ],
+        metadata: {
+          ...metadata,
+          status: "tripwire",
+          tripwire: {
+            retry: chunk.payload.retry,
+            tripwirePayload: chunk.payload.metadata,
+            processorId: chunk.payload.processorId
+          }
+        }
+      };
+      return [...result, newMessage];
+    }
+    case "start": {
+      const newMessage = {
+        id: typeof chunk.payload.messageId === "string" ? chunk.payload.messageId : `start-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [],
+        metadata
+      };
+      return [...result, newMessage];
+    }
+    case "text-start": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const textId = chunk.payload.id || `text-${Date.now()}`;
+      const newTextPart = {
+        type: "text",
+        text: "",
+        state: "streaming",
+        textId,
+        providerMetadata: chunk.payload.providerMetadata
+      };
+      if (lastMessage.metadata?.completionResult) {
+        const newMessage = {
+          id: `start-${chunk.runId}-${Date.now()}`,
+          role: "assistant",
+          parts: [newTextPart],
+          metadata
+        };
+        return [...result, newMessage];
+      }
+      const parts = [...lastMessage.parts];
+      parts.push(newTextPart);
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "text-delta": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      const textId = chunk.payload.id;
+      let textPartIndex = textId ? parts.findLastIndex((part) => part.type === "text" && part.textId === textId) : -1;
+      if (textPartIndex === -1) {
+        textPartIndex = parts.findLastIndex(
+          (part) => part.type === "text" && part.state === "streaming"
+        );
+      }
+      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];
+        if (textPart.type === "text") {
+          const extendedTextPart = textPart;
+          const updatedTextPart = {
+            ...extendedTextPart,
+            text: extendedTextPart.text + chunk.payload.text,
+            state: "streaming"
+          };
+          parts[textPartIndex] = updatedTextPart;
+        }
+      }
+      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-error":
+    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" || typeof part.type === "string" && part.type.startsWith("tool-")) && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+      );
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool" || typeof toolPart.type === "string" && toolPart.type.startsWith("tool-")) {
+          const toolName = "toolName" in toolPart && typeof toolPart.toolName === "string" ? toolPart.toolName : toolPart.type.startsWith("tool-") ? toolPart.type.substring(5) : "";
+          const toolCallId = toolPart.toolCallId;
+          if (chunk.type === "tool-result" && chunk.payload.isError || chunk.type === "tool-error") {
+            const error = chunk.type === "tool-error" ? chunk.payload.error : chunk.payload.result;
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName,
+              toolCallId,
+              state: "output-error",
+              input: toolPart.input,
+              errorText: typeof error === "string" ? error : error instanceof Error ? error.message : error?.message ?? String(error),
+              callProviderMetadata: chunk.payload.providerMetadata
+            };
+          } else {
+            const isWorkflow = Boolean(chunk.payload.result?.result?.steps);
+            const isAgent = chunk?.from === "AGENT";
+            let output;
+            if (isWorkflow) {
+              output = chunk.payload.result?.result;
+            } else if (isAgent) {
+              output = parts[toolPartIndex].output ?? chunk.payload.result;
+            } else {
+              output = chunk.payload.result;
+            }
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName,
+              toolCallId,
+              state: "output-available",
+              input: toolPart.input,
+              output,
+              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" || typeof part.type === "string" && part.type.startsWith("tool-")) && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+      );
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool" || typeof toolPart.type === "string" && toolPart.type.startsWith("tool-")) {
+          const toolName = "toolName" in toolPart && typeof toolPart.toolName === "string" ? toolPart.toolName : typeof toolPart.type === "string" && toolPart.type.startsWith("tool-") ? toolPart.type.substring(5) : "";
+          const toolCallId = toolPart.toolCallId;
+          const input = toolPart.input;
+          if (chunk.payload.output?.type?.startsWith("workflow-")) {
+            const existingWorkflowState = toolPart.output || {};
+            const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(
+              existingWorkflowState,
+              chunk.payload.output
+            );
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName,
+              toolCallId,
+              state: "input-streaming",
+              input,
+              output: updatedWorkflowState
+            };
+          } else if (chunk.payload.output?.from === "AGENT" || chunk.payload.output?.from === "USER" && chunk.payload.output?.payload?.output?.type?.startsWith("workflow-")) {
+            return toUIMessageFromAgent(chunk.payload.output, conversation, metadata, toolCallId, toolName);
+          } else {
+            const currentOutput = toolPart.output || [];
+            const existingOutput = Array.isArray(currentOutput) ? currentOutput : [];
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName,
+              toolCallId,
+              state: "input-streaming",
+              input,
+              output: [...existingOutput, chunk.payload.output]
+            };
+          }
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "is-task-complete": {
+      if (chunk.payload.suppressFeedback) return result;
+      const feedback = loop.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 = {
+        id: `is-task-complete-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: feedback
+          }
+        ],
+        metadata: {
+          ...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.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 "tool-call-approval": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "stream" ? lastMessage.metadata?.requireApprovalMetadata : {};
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "stream",
+            requireApprovalMetadata: {
+              ...lastRequireApprovalMetadata,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args
+              }
+            }
+          }
+        }
+      ];
+    }
+    case "tool-call-suspended": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const lastSuspendedTools = lastMessage.metadata?.mode === "stream" ? lastMessage.metadata?.suspendedTools : {};
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "stream",
+            suspendedTools: {
+              ...lastSuspendedTools,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args,
+                suspendPayload: chunk.payload.suspendPayload
+              }
+            }
+          }
+        }
+      ];
+    }
+    case "finish": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = lastMessage.parts.map((part) => {
+        if (typeof part === "object" && part !== null && "type" in part && "state" in part && part.state === "streaming") {
+          if (part.type === "text" || part.type === "reasoning") {
+            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;
+  }
+};
+var toUIMessageFromAgent = (chunk, conversation, metadata, parentToolCallId, parentToolName) => {
+  const lastMessage = conversation[conversation.length - 1];
+  if (!lastMessage || lastMessage.role !== "assistant") return conversation;
+  const parts = [...lastMessage.parts];
+  if (chunk.type === "text-delta") {
+    const agentChunk = chunk.payload;
+    const toolPartIndex = parts.findIndex(
+      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
+    );
+    if (toolPartIndex === -1) return conversation;
+    const toolPart = parts[toolPartIndex];
+    const childMessages = toolPart?.output?.childMessages || [];
+    const lastChildMessage = childMessages[childMessages.length - 1];
+    const textMessage = { type: "text", content: (lastChildMessage?.content || "") + agentChunk.text };
+    const nextMessages = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+    parts[toolPartIndex] = {
+      ...toolPart,
+      output: {
+        childMessages: nextMessages
+      }
+    };
+  } else if (chunk.type === "tool-call") {
+    const agentChunk = chunk.payload;
+    const toolPartIndex = parts.findIndex(
+      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
+    );
+    if (toolPartIndex === -1) return conversation;
+    const toolPart = parts[toolPartIndex];
+    const childMessages = toolPart?.output?.childMessages || [];
+    parts[toolPartIndex] = {
+      ...toolPart,
+      output: {
+        ...toolPart?.output,
+        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 = parts.findIndex(
+      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
+    );
+    if (toolPartIndex === -1) return conversation;
+    const toolPart = parts[toolPartIndex];
+    if (agentChunk?.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.output);
+      if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+        parts[toolPartIndex] = {
+          ...toolPart,
+          output: {
+            ...toolPart?.output,
+            childMessages: [
+              ...childMessages.slice(0, -1),
+              {
+                ...currentMessage,
+                toolOutput: { ...updatedWorkflowState, runId: agentChunk.output.runId }
+              }
+            ]
+          }
+        };
+      }
+    }
+  } else if (chunk.type === "tool-result") {
+    const agentChunk = chunk.payload;
+    const toolPartIndex = parts.findIndex(
+      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
+    );
+    if (toolPartIndex === -1) return conversation;
+    const toolPart = parts[toolPartIndex];
+    const childMessages = toolPart?.output?.childMessages || [];
+    const lastToolIndex = childMessages.length - 1;
+    const isWorkflow = agentChunk?.toolName?.startsWith("workflow-");
+    if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+      parts[toolPartIndex] = {
+        ...toolPart,
+        output: {
+          ...toolPart?.output,
+          childMessages: [
+            ...childMessages.slice(0, -1),
+            {
+              ...childMessages[lastToolIndex],
+              toolOutput: isWorkflow ? { ...agentChunk.result?.result, runId: agentChunk.result?.runId } : agentChunk.result
+            }
+          ]
+        }
+      };
+    }
+  }
+  return [
+    ...conversation.slice(0, -1),
+    {
+      ...lastMessage,
+      parts
+    }
+  ];
+};
 
+// src/lib/ai-sdk/utils/toAssistantUIMessage.ts
+var 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") {
+      const type = part.mediaType.includes("image/") ? "image" : "file";
+      if (type === "file") {
+        return {
+          type,
+          mimeType: part.mediaType,
+          data: part.url,
+          // Use URL as data source
+          metadata: message.metadata
+        };
+      }
+      if (type === "image") {
+        return {
+          type,
+          image: part.url,
+          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 toolName2 = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.substring(5);
+      const { suspendedToolRunId, ...cleanInput } = "input" in part ? part.input : {};
+      const baseToolCall = {
+        type: "tool-call",
+        toolCallId: "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "",
+        toolName: toolName2,
+        argsText: JSON.stringify(cleanInput ?? {}),
+        args: cleanInput ?? {},
+        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;
+    }
+    const toolName = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.startsWith("tool-") ? part.type.substring(5) : "";
+    const requireApprovalMetadata = extendedMessage.metadata?.requireApprovalMetadata;
+    const suspendedTools = extendedMessage.metadata?.suspendedTools;
+    const partToolCallId = "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : void 0;
+    const suspensionData = toolName ? requireApprovalMetadata?.[toolName] ?? suspendedTools?.[toolName] : void 0;
+    if (suspensionData) {
+      const { suspendedToolRunId, ...cleanInput } = "input" in part ? part.input : {};
+      return {
+        type: "tool-call",
+        toolCallId: partToolCallId,
+        toolName,
+        argsText: JSON.stringify(cleanInput ?? {}),
+        args: cleanInput,
+        metadata: extendedMessage.metadata
+      };
+    }
+    if (part.type.startsWith("data-")) {
+      return {
+        type: "data",
+        name: part.type.substring(5),
+        // Extract name from 'data-{name}'
+        data: part.data,
+        metadata: message.metadata
+      };
+    }
+    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;
+};
 
+// src/lib/ai-sdk/memory/resolveInitialMessages.ts
+var resolveInitialMessages = (messages) => {
+  const messagesLength = messages.length;
+  return messages.map((message, index) => {
+    const networkPart = message.parts.find(
+      (part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string" && 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 messages2 = finalResult?.messages || [];
+          const childMessages = [];
+          const toolResultMap = /* @__PURE__ */ new Map();
+          for (const msg of messages2) {
+            if (Array.isArray(msg.content)) {
+              for (const part of msg.content) {
+                if (typeof part === "object" && part.type === "tool-result") {
+                  toolResultMap.set(part.toolCallId, part);
+                }
+              }
+            }
+          }
+          for (const msg of messages2) {
+            if (msg.type === "tool-call" && Array.isArray(msg.content)) {
+              for (const part of msg.content) {
+                if (typeof part === "object" && part.type === "tool-call") {
+                  const toolCallContent = part;
+                  const toolResult = toolResultMap.get(toolCallContent.toolCallId);
+                  const isWorkflow = Boolean(toolResult?.result?.result?.steps);
+                  childMessages.push({
+                    type: "tool",
+                    toolCallId: toolCallContent.toolCallId,
+                    toolName: toolCallContent.toolName,
+                    args: toolCallContent.args,
+                    toolOutput: isWorkflow ? toolResult?.result?.result : toolResult?.result
+                  });
+                }
+              }
+            }
+          }
+          if (finalResult && finalResult.text) {
+            childMessages.push({
+              type: "text",
+              content: finalResult.text
+            });
+          }
+          const result = primitiveType === "tool" ? finalResult?.result : {
+            childMessages,
+            result: finalResult?.text || ""
+          };
+          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,
+              hasMoreMessages: index < messagesLength - 1,
+              from: primitiveType === "agent" ? "AGENT" : primitiveType === "tool" ? "TOOL" : "WORKFLOW"
+            }
+          };
+          return nextMessage;
+        }
+      } catch {
+        return message;
+      }
+    }
+    const extendedMessage = message;
+    const pendingToolApprovals = extendedMessage.metadata?.pendingToolApprovals;
+    if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
+      return {
+        ...message,
+        metadata: {
+          ...message.metadata,
+          mode: "stream",
+          requireApprovalMetadata: pendingToolApprovals
+        }
+      };
+    }
+    const suspendedTools = extendedMessage.metadata?.suspendedTools;
+    if (suspendedTools && typeof suspendedTools === "object") {
+      return {
+        ...message,
+        metadata: {
+          ...message.metadata,
+          mode: "stream",
+          suspendedTools
+        }
+      };
+    }
+    return message;
+  })?.filter((message) => {
+    const completionModes = ["generate", "stream", "network"];
+    if (message.role === "assistant" && completionModes.includes(message?.metadata?.mode)) {
+      const meta = message.metadata;
+      if (meta?.isTaskCompleteResult?.suppressFeedback || meta?.completionResult?.suppressFeedback) {
+        return false;
+      }
+      return true;
+    }
+    return true;
+  });
+};
+var resolveToChildMessages = (messages) => {
+  const assistantMessage = messages.find((message) => message.role === "assistant");
+  if (!assistantMessage) return [];
+  const parts = assistantMessage.parts;
+  let childMessages = [];
+  for (const part of parts) {
+    const toolPart = part;
+    if (part.type.startsWith("tool-")) {
+      const toolName = part.type.substring("tool-".length);
+      const isWorkflow = toolName.startsWith("workflow-");
+      childMessages.push({
+        type: "tool",
+        toolCallId: toolPart.toolCallId,
+        toolName,
+        args: toolPart.input,
+        toolOutput: isWorkflow ? { ...toolPart.output?.result, runId: toolPart.output?.runId } : toolPart.output
+      });
+    }
+    if (part.type === "text") {
+      childMessages.push({
+        type: "text",
+        content: toolPart.text
+      });
+    }
+  }
+  return childMessages;
+};
+var AISdkNetworkTransformer = class {
+  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-validation-end") {
+      if (chunk.payload.suppressFeedback) return newConversation;
+      const feedback = loop.formatCompletionFeedback(
+        {
+          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 = {
+        id: `network-validation-end-${chunk.payload.runId}-${Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: feedback
+          }
+        ],
+        metadata: {
+          ...metadata,
+          mode: "network",
+          completionResult: {
+            passed: chunk.payload.passed
+          }
+        }
+      };
+      return [...newConversation, newMessage];
+    }
+    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-approval") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.requireApprovalMetadata : {};
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "network",
+            requireApprovalMetadata: {
+              ...lastRequireApprovalMetadata,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args,
+                runId: chunk.payload.runId
+              }
+            }
+          }
+        }
+      ];
+    }
+    if (chunk.type === "agent-execution-suspended") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "network",
+            suspendedTools: {
+              ...lastSuspendedTools,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args,
+                suspendPayload: chunk.payload.suspendPayload
+              }
+            }
+          }
+        }
+      ];
+    }
+    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 {
+        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 === "workflow-execution-suspended") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "network",
+            suspendedTools: {
+              ...lastSuspendedTools,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args,
+                suspendPayload: chunk.payload.suspendPayload
+              }
+            }
+          }
+        }
+      ];
+    }
+    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-approval") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.requireApprovalMetadata : {};
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "network",
+            requireApprovalMetadata: {
+              ...lastRequireApprovalMetadata,
+              [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 = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          metadata: {
+            ...lastMessage.metadata,
+            mode: "network",
+            suspendedTools: {
+              ...lastSuspendedTools,
+              [chunk.payload.toolName]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args,
+                suspendPayload: chunk.payload.suspendPayload
+              }
+            }
+          }
+        }
+      ];
+    }
+    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;
+  };
+};
 
-exports.AgentIcon = index.AgentIcon;
-exports.CodeBlock = index.CodeBlock;
-exports.CodeBlockClass = index.CodeBlockClass;
-exports.CodeCopyButton = index.CodeCopyButton;
-exports.Entity = index.Entity;
-exports.EntityCaret = index.EntityCaret;
-exports.EntityContent = index.EntityContent;
-exports.EntityContentClass = index.EntityContentClass;
-exports.EntityTrigger = index.EntityTrigger;
-exports.EntityTriggerClass = index.EntityTriggerClass;
-exports.EntityTriggerVariantClasses = index.EntityTriggerVariantClasses;
-exports.Entry = index.Entry;
-exports.EntryClass = index.EntryClass;
-exports.EntryTitle = index.EntryTitle;
-exports.EntryTitleClass = index.EntryTitleClass;
-exports.Icon = index.Icon;
-exports.IconButton = index.IconButton;
-exports.IconButtonClass = index.IconButtonClass;
-exports.IconSizes = index.IconSizes;
-exports.MastraReactProvider = index.MastraReactProvider;
-exports.Message = index.Message;
-exports.MessageActions = index.MessageActions;
-exports.MessageActionsClass = index.MessageActionsClass;
-exports.MessageClass = index.MessageClass;
-exports.MessageContent = index.MessageContent;
-exports.MessageContentClass = index.MessageContentClass;
-exports.MessageList = index.MessageList;
-exports.MessageListClass = index.MessageListClass;
-exports.MessageStreaming = index.MessageStreaming;
-exports.MessageStreamingClass = index.MessageStreamingClass;
-exports.MessageUsage = index.MessageUsage;
-exports.MessageUsageClass = index.MessageUsageClass;
-exports.MessageUsageEntry = index.MessageUsageEntry;
-exports.MessageUsageEntryClass = index.MessageUsageEntryClass;
-exports.MessageUsageValue = index.MessageUsageValue;
-exports.MessageUsageValueClass = index.MessageUsageValueClass;
-exports.MessageUsages = index.MessageUsages;
-exports.MessageUsagesClass = index.MessageUsagesClass;
-exports.ToolApproval = index.ToolApproval;
-exports.ToolApprovalActions = index.ToolApprovalActions;
-exports.ToolApprovalActionsClass = index.ToolApprovalActionsClass;
-exports.ToolApprovalClass = index.ToolApprovalClass;
-exports.ToolApprovalContent = index.ToolApprovalContent;
-exports.ToolApprovalContentClass = index.ToolApprovalContentClass;
-exports.ToolApprovalHeader = index.ToolApprovalHeader;
-exports.ToolApprovalHeaderClass = index.ToolApprovalHeaderClass;
-exports.ToolApprovalTitle = index.ToolApprovalTitle;
-exports.ToolApprovalTitleClass = index.ToolApprovalTitleClass;
-exports.ToolsIcon = index.ToolsIcon;
-exports.Tooltip = index.Tooltip;
-exports.TooltipContent = index.TooltipContent;
-exports.TooltipContentClass = index.TooltipContentClass;
-exports.TooltipTrigger = index.TooltipTrigger;
-exports.WorkflowIcon = index.WorkflowIcon;
-exports.mapWorkflowStreamChunkToWatchResult = index.mapWorkflowStreamChunkToWatchResult;
-exports.resolveToChildMessages = index.resolveToChildMessages;
-exports.toAssistantUIMessage = index.toAssistantUIMessage;
-exports.toUIMessage = index.toUIMessage;
-exports.useCancelWorkflowRun = index.useCancelWorkflowRun;
-exports.useChat = index.useChat;
-exports.useCreateWorkflowRun = index.useCreateWorkflowRun;
-exports.useEntity = index.useEntity;
-exports.useMastraClient = index.useMastraClient;
-exports.useStreamWorkflow = index.useStreamWorkflow;
+// src/lib/ai-sdk/utils/fromCoreUserMessageToUIMessage.tsx
+var fromCoreUserMessageToUIMessage = (coreUserMessage) => {
+  const id = `user-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  const parts = 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 url = typeof part.image === "string" ? part.image : part.image instanceof URL ? part.image.toString() : "";
+        return {
+          type: "file",
+          mediaType: part.mimeType ?? "image/*",
+          url
+        };
+      }
+      case "file": {
+        const url = typeof part.data === "string" ? part.data : part.data instanceof URL ? part.data.toString() : "";
+        return {
+          type: "file",
+          mediaType: part.mimeType,
+          url,
+          ...part.filename !== void 0 ? { filename: part.filename } : {}
+        };
+      }
+      default: {
+        const exhaustiveCheck = part;
+        throw new Error(`Unhandled content part type: ${exhaustiveCheck.type}`);
+      }
+    }
+  });
+  return {
+    id,
+    role: "user",
+    parts
+  };
+};
+
+// src/agent/hooks.ts
+var extractRunIdFromMessages = (messages) => {
+  for (const message of messages) {
+    const pendingToolApprovals = message.metadata?.pendingToolApprovals;
+    if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
+      const suspensionData = Object.values(pendingToolApprovals)[0];
+      if (suspensionData?.runId) {
+        return suspensionData.runId;
+      }
+    }
+  }
+  return void 0;
+};
+var useChat = ({ agentId, resourceId, initialMessages }) => {
+  const _currentRunId = react.useRef(void 0);
+  const _onChunk = react.useRef(void 0);
+  const _networkRunId = react.useRef(void 0);
+  const _onNetworkChunk = react.useRef(void 0);
+  const [messages, setMessages] = react.useState([]);
+  const [toolCallApprovals, setToolCallApprovals] = react.useState({});
+  const [networkToolCallApprovals, setNetworkToolCallApprovals] = react.useState({});
+  const baseClient = useMastraClient();
+  const [isRunning, setIsRunning] = react.useState(false);
+  react.useEffect(() => {
+    const formattedMessages = resolveInitialMessages(initialMessages || []);
+    setMessages(formattedMessages);
+    _currentRunId.current = extractRunIdFromMessages(formattedMessages);
+  }, [initialMessages]);
+  const generate = async ({
+    coreUserMessages,
+    requestContext,
+    threadId,
+    modelSettings,
+    signal,
+    onFinish,
+    tracingOptions
+  }) => {
+    const {
+      frequencyPenalty,
+      presencePenalty,
+      maxRetries,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      instructions,
+      providerOptions,
+      maxSteps,
+      requireToolApproval
+    } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new clientJs.MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const runId = uuid.v4();
+    _currentRunId.current = runId;
+    const response = await agent.generate(coreUserMessages, {
+      runId,
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      requestContext,
+      ...threadId ? { memory: { thread: threadId, resource: resourceId || agentId } } : {},
+      providerOptions,
+      tracingOptions,
+      requireToolApproval
+    });
+    if (response.finishReason === "suspended" && response.suspendPayload) {
+      const { toolCallId, toolName, args } = response.suspendPayload;
+      if (response.response?.uiMessages) {
+        const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
+          ...message,
+          metadata: {
+            mode: "generate",
+            requireApprovalMetadata: {
+              [toolName]: {
+                toolCallId,
+                toolName,
+                args
+              }
+            }
+          }
+        }));
+        setMessages((prev) => [...prev, ...mastraUIMessages]);
+      }
+      setIsRunning(false);
+      return;
+    }
+    setIsRunning(false);
+    if (response && "uiMessages" in response.response && response.response.uiMessages) {
+      void onFinish?.(response.response.uiMessages);
+      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
+        ...message,
+        metadata: {
+          mode: "generate"
+        }
+      }));
+      setMessages((prev) => [...prev, ...mastraUIMessages]);
+    }
+  };
+  const stream = async ({
+    coreUserMessages,
+    requestContext,
+    threadId,
+    onChunk,
+    modelSettings,
+    signal,
+    tracingOptions
+  }) => {
+    const {
+      frequencyPenalty,
+      presencePenalty,
+      maxRetries,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      instructions,
+      providerOptions,
+      maxSteps,
+      requireToolApproval
+    } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new clientJs.MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const runId = uuid.v4();
+    const response = await agent.stream(coreUserMessages, {
+      runId,
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      requestContext,
+      ...threadId ? { memory: { thread: threadId, resource: resourceId || agentId } } : {},
+      providerOptions,
+      requireToolApproval,
+      tracingOptions
+    });
+    _onChunk.current = onChunk;
+    _currentRunId.current = runId;
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
+        void onChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const network = async ({
+    coreUserMessages,
+    requestContext,
+    threadId,
+    onNetworkChunk,
+    modelSettings,
+    signal,
+    tracingOptions
+  }) => {
+    const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new clientJs.MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const runId = uuid.v4();
+    const response = await agent.network(coreUserMessages, {
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      runId,
+      requestContext,
+      ...threadId ? { memory: { thread: threadId, resource: resourceId || agentId } } : {},
+      tracingOptions
+    });
+    _onNetworkChunk.current = onNetworkChunk;
+    _networkRunId.current = runId;
+    const transformer = new AISdkNetworkTransformer();
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        void onNetworkChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const handleCancelRun = () => {
+    setIsRunning(false);
+    _currentRunId.current = void 0;
+    _onChunk.current = void 0;
+    _networkRunId.current = void 0;
+    _onNetworkChunk.current = void 0;
+  };
+  const approveToolCall = async (toolCallId) => {
+    const onChunk = _onChunk.current;
+    const currentRunId = _currentRunId.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);
+    const response = await agent.approveToolCall({ runId: currentRunId, toolCallId });
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
+        void onChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const declineToolCall = async (toolCallId) => {
+    const onChunk = _onChunk.current;
+    const currentRunId = _currentRunId.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);
+    const response = await agent.declineToolCall({ runId: currentRunId, toolCallId });
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
+        void onChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const approveToolCallGenerate = async (toolCallId) => {
+    const currentRunId = _currentRunId.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 agent = baseClient.getAgent(agentId);
+    const response = await agent.approveToolCallGenerate({ runId: currentRunId, toolCallId });
+    if (response && "uiMessages" in response.response && response.response.uiMessages) {
+      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
+        ...message,
+        metadata: {
+          mode: "generate"
+        }
+      }));
+      setMessages((prev) => [...prev, ...mastraUIMessages]);
+    }
+    setIsRunning(false);
+  };
+  const declineToolCallGenerate = async (toolCallId) => {
+    const currentRunId = _currentRunId.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 agent = baseClient.getAgent(agentId);
+    const response = await agent.declineToolCallGenerate({ runId: currentRunId, toolCallId });
+    if (response && "uiMessages" in response.response && response.response.uiMessages) {
+      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
+        ...message,
+        metadata: {
+          mode: "generate"
+        }
+      }));
+      setMessages((prev) => [...prev, ...mastraUIMessages]);
+    }
+    setIsRunning(false);
+  };
+  const approveNetworkToolCall = async (toolName, runId) => {
+    const onNetworkChunk = _onNetworkChunk.current;
+    const networkRunId = runId || _networkRunId.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" }
+    }));
+    const agent = baseClient.getAgent(agentId);
+    const response = await agent.approveNetworkToolCall({ runId: networkRunId });
+    const transformer = new AISdkNetworkTransformer();
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        void onNetworkChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const declineNetworkToolCall = async (toolName, runId) => {
+    const onNetworkChunk = _onNetworkChunk.current;
+    const networkRunId = runId || _networkRunId.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" }
+    }));
+    const agent = baseClient.getAgent(agentId);
+    const response = await agent.declineNetworkToolCall({ runId: networkRunId });
+    const transformer = new AISdkNetworkTransformer();
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        void onNetworkChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const sendMessage = async ({ mode = "stream", ...args }) => {
+    const nextMessage = { role: "user", content: [{ type: "text", text: args.message }] };
+    const coreUserMessages = [nextMessage];
+    if (args.coreUserMessages) {
+      coreUserMessages.push(...args.coreUserMessages);
+    }
+    const uiMessages = coreUserMessages.map(fromCoreUserMessageToUIMessage);
+    setMessages((s) => [...s, ...uiMessages]);
+    if (mode === "generate") {
+      await generate({ ...args, coreUserMessages });
+    } else if (mode === "stream") {
+      await stream({ ...args, coreUserMessages });
+    } else if (mode === "network") {
+      await network({ ...args, coreUserMessages });
+    }
+  };
+  return {
+    setMessages,
+    sendMessage,
+    isRunning,
+    messages,
+    approveToolCall,
+    declineToolCall,
+    approveToolCallGenerate,
+    declineToolCallGenerate,
+    cancelRun: handleCancelRun,
+    toolCallApprovals,
+    approveNetworkToolCall,
+    declineNetworkToolCall,
+    networkToolCallApprovals
+  };
+};
+var IconSizes = {
+  sm: "mastra:[&>svg]:size-3",
+  md: "mastra:[&>svg]:size-4",
+  lg: "mastra:[&>svg]:size-5"
+};
+var Icon = ({ children, className, size = "md", ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || IconSizes[size], ...props, children });
+};
+var EntityContext = react.createContext({
+  expanded: false,
+  setExpanded: () => {
+  },
+  variant: "initial",
+  disabled: false
+});
+var EntityProvider = EntityContext.Provider;
+var useEntity = () => react.useContext(EntityContext);
+var Entity = ({
+  className,
+  variant = "initial",
+  initialExpanded = false,
+  disabled = false,
+  ...props
+}) => {
+  const [expanded, setExpanded] = react.useState(initialExpanded);
+  return /* @__PURE__ */ jsxRuntime.jsx(EntityProvider, { value: { expanded, setExpanded, variant, disabled }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className, ...props }) });
+};
+var EntityTriggerClass = tailwindMerge.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"
+);
+var 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"
+};
+var EntityTrigger = ({ className, children, ...props }) => {
+  const { expanded, setExpanded, variant, disabled } = useEntity();
+  const handleClick = (e) => {
+    if (disabled) return;
+    setExpanded(!expanded);
+    props?.onClick?.(e);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      className: className || tailwindMerge.twMerge(EntityTriggerClass, !disabled && EntityTriggerVariantClasses[variant]),
+      ...props,
+      onClick: handleClick,
+      "aria-expanded": expanded,
+      "aria-disabled": disabled,
+      children
+    }
+  );
+};
+var EntityContentClass = tailwindMerge.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"
+);
+var EntityContent = ({ className, ...props }) => {
+  const { expanded } = useEntity();
+  if (!expanded) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || EntityContentClass, ...props });
+};
+var EntityCaret = ({ className, ...props }) => {
+  const { expanded } = useEntity();
+  return /* @__PURE__ */ jsxRuntime.jsx(Icon, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    lucideReact.ChevronDownIcon,
+    {
+      className: tailwindMerge.twMerge(
+        `mastra:text-text3 mastra:transition-transform mastra:duration-200 mastra:ease-in-out`,
+        expanded ? "mastra:rotate-0" : "mastra:-rotate-90",
+        className
+      ),
+      ...props
+    }
+  ) });
+};
+var ToolApprovalClass = tailwindMerge.twMerge(
+  "mastra:rounded-lg mastra:border mastra:border-border1 mastra:max-w-1/2 mastra:mt-2",
+  "mastra:bg-surface3 mastra:text-text6"
+);
+var ToolApproval = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalClass, ...props });
+};
+var ToolApprovalTitleClass = tailwindMerge.twMerge("mastra:text-text6 mastra:inline-flex mastra:items-center mastra:gap-1");
+var ToolApprovalTitle = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalTitleClass, ...props });
+};
+var ToolApprovalHeaderClass = tailwindMerge.twMerge(
+  "mastra:flex mastra:justify-between mastra:items-center mastra:gap-2",
+  "mastra:border-b mastra:border-border1 mastra:px-4 mastra:py-2"
+);
+var ToolApprovalHeader = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalHeaderClass, ...props });
+};
+var ToolApprovalContentClass = tailwindMerge.twMerge("mastra:text-text6 mastra:p-4");
+var ToolApprovalContent = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalContentClass, ...props });
+};
+var ToolApprovalActionsClass = tailwindMerge.twMerge("mastra:flex mastra:gap-2 mastra:items-center");
+var ToolApprovalActions = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalActionsClass, ...props });
+};
+var EntryClass = "mastra:space-y-2";
+var Entry = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || EntryClass, ...props });
+};
+var EntryTitleClass = "mastra:font-mono mastra:text-sm mastra:text-text3";
+var EntryTitle = ({ className, as: Root = "h3", ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(Root, { className: className || EntryTitleClass, ...props });
+};
+var Tooltip = ({ children }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.Root, { children }) });
+};
+var 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";
+var TooltipContent = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipContent, { className: className || TooltipContentClass, ...props, children }) });
+};
+var TooltipTrigger = (props) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipTrigger, { ...props, asChild: true });
+};
+var 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";
+var IconButton = ({ children, tooltip, size = "md", className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(TooltipTrigger, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ...props,
+        className: className || tailwindMerge.twMerge(IconButtonClass, size === "md" && "mastra:p-0.5", size === "lg" && "mastra:p-1"),
+        children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { size, children })
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(TooltipContent, { children: tooltip })
+  ] });
+};
+async function highlight(code, lang) {
+  const out = await web.codeToHast(code, {
+    lang,
+    theme: "dracula-soft"
+  });
+  return hastUtilToJsxRuntime.toJsxRuntime(out, {
+    Fragment: react.Fragment,
+    jsx: jsxRuntime.jsx,
+    jsxs: jsxRuntime.jsxs
+  });
+}
+var CodeBlockClass = "mastra:rounded-lg mastra:[&>pre]:p-4 mastra:overflow-hidden mastra:[&>pre]:!bg-surface4 mastra:[&>pre>code]:leading-5 mastra:relative";
+var CodeBlock = ({ code, language, className, cta }) => {
+  const [nodes, setNodes] = react.useState(null);
+  react.useLayoutEffect(() => {
+    void highlight(code, language).then(setNodes);
+  }, [language]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className || CodeBlockClass, children: [
+    nodes ?? null,
+    cta
+  ] });
+};
+var CodeCopyButton = ({ code }) => {
+  const [isCopied, setIsCopied] = react.useState(false);
+  const handleCopy = () => {
+    void navigator.clipboard.writeText(code);
+    setIsCopied(true);
+    setTimeout(() => setIsCopied(false), 2e3);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mastra:absolute mastra:top-2 mastra:right-2", children: /* @__PURE__ */ jsxRuntime.jsx(IconButton, { tooltip: "Copy", onClick: handleCopy, children: isCopied ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CheckIcon, {}) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CopyIcon, {}) }) });
+};
+var AgentIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsxs(
+  "svg",
+  {
+    width: "17",
+    height: "16",
+    viewBox: "0 0 17 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    className: tailwindMerge.twMerge("mastra-icon", className),
+    children: [
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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"
+        }
+      )
+    ]
+  }
+);
+var ToolsIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "svg",
+  {
+    width: "17",
+    height: "16",
+    viewBox: "0 0 17 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    className: tailwindMerge.twMerge("mastra-icon", className),
+    children: /* @__PURE__ */ jsxRuntime.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"
+      }
+    )
+  }
+);
+var WorkflowIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "svg",
+  {
+    width: "17",
+    height: "16",
+    viewBox: "0 0 17 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    className: tailwindMerge.twMerge("mastra-icon", className),
+    children: /* @__PURE__ */ jsxRuntime.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"
+      }
+    )
+  }
+);
+var MessageClass = "mastra:flex mastra:flex-col mastra:w-full mastra:py-4 mastra:gap-2 mastra:group";
+var Message = ({ position, className, children, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: className || tailwindMerge.twMerge(
+        MessageClass,
+        position === "left" ? "" : "mastra:items-end mastra:[&_.mastra-message-content]:bg-surface4 mastra:[&_.mastra-message-content]:px-4"
+      ),
+      ...props,
+      children
+    }
+  );
+};
+var MessageContentClass = "mastra:max-w-4/5 mastra:py-2 mastra:text-text6 mastra:rounded-lg mastra-message-content mastra:text-md";
+var MessageContent = ({ children, className, isStreaming, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: className || MessageContentClass, ...props, children: [
+    children,
+    isStreaming && /* @__PURE__ */ jsxRuntime.jsx(MessageStreaming, {})
+  ] });
+};
+var MessageActionsClass = "mastra:gap-2 mastra:flex mastra:opacity-0 mastra:group-hover:opacity-100 mastra:group-focus-within:opacity-100 mastra:items-center";
+var MessageActions = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || MessageActionsClass, ...props, children });
+};
+var MessageUsagesClass = "mastra:flex mastra:gap-2 mastra:items-center";
+var MessageUsages = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || MessageUsagesClass, ...props, children });
+};
+var 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";
+var MessageUsage = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("dl", { className: className || MessageUsageClass, ...props, children });
+};
+var MessageUsageEntryClass = "mastra:text-text3 mastra:text-xs mastra:flex mastra:gap-1 mastra:items-center";
+var MessageUsageEntry = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("dt", { className: className || MessageUsageEntryClass, ...props, children });
+};
+var MessageUsageValueClass = "mastra:text-text6 mastra:text-xs";
+var MessageUsageValue = ({ children, className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("dd", { className: className || MessageUsageValueClass, ...props, children });
+};
+var MessageListClass = "mastra:overflow-y-auto mastra:h-full mastra-list";
+var MessageList = ({ children, className, ...props }) => {
+  const listRef = react.useRef(null);
+  react.useEffect(() => {
+    const scrollToBottom = () => {
+      if (!listRef.current) return;
+      listRef.current.scrollTo({ top: listRef.current.scrollHeight, behavior: "smooth" });
+    };
+    requestAnimationFrame(scrollToBottom);
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || MessageListClass, ...props, ref: listRef, children });
+};
+var MessageStreamingClass = "mastra:inline-block mastra:w-[2px] mastra:h-[1em] mastra:bg-text5 mastra:ml-0.5 mastra:align-text-bottom mastra:animate-pulse";
+var MessageStreaming = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { className: className || MessageStreamingClass, ...props });
+};
+function useMutation(mutationFn) {
+  const [isPending, setIsPending] = react.useState(false);
+  const [isSuccess, setIsSuccess] = react.useState(false);
+  const [isError, setIsError] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [data, setData] = react.useState(void 0);
+  const mutationFnRef = react.useRef(mutationFn);
+  mutationFnRef.current = mutationFn;
+  const reset = react.useCallback(() => {
+    setIsPending(false);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+    setData(void 0);
+  }, []);
+  const mutateAsync = react.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) {
+      const typedError = err;
+      setError(typedError);
+      setIsError(true);
+      throw err;
+    } finally {
+      setIsPending(false);
+    }
+  }, []);
+  const mutate = react.useCallback(
+    (variables) => {
+      mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return {
+    mutate,
+    mutateAsync,
+    isPending,
+    isSuccess,
+    isError,
+    error,
+    data,
+    reset
+  };
+}
+function useStreamWorkflow({ debugMode, tracingOptions, onError }) {
+  const client = useMastraClient();
+  const [streamResult, setStreamResult] = react.useState({});
+  const [isStreaming, setIsStreaming] = react.useState(false);
+  const readerRef = react.useRef(null);
+  const observerRef = react.useRef(null);
+  const resumeStreamRef = react.useRef(null);
+  const timeTravelStreamRef = react.useRef(null);
+  const isMountedRef = react.useRef(true);
+  react.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 = react.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 = react.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 requestContext$1 = new requestContext.RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext$1.set(key, value);
+      });
+      const workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      const stream = await run.stream({
+        inputData,
+        initialState,
+        requestContext: requestContext$1,
+        closeOnSuspend: true,
+        tracingOptions,
+        perStep: perStep ?? debugMode
+      });
+      if (!stream) {
+        return handleStreamError(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) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            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 workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      const stream = await run.observeStream();
+      if (!stream) {
+        return handleStreamError(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) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            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 workflow = client.getWorkflow(workflowId);
+      const requestContext$1 = new requestContext.RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext$1.set(key, value);
+      });
+      const run = await workflow.createRun({ runId });
+      const stream = await run.resumeStream({
+        step,
+        resumeData,
+        requestContext: requestContext$1,
+        tracingOptions,
+        perStep: perStep ?? debugMode
+      });
+      if (!stream) {
+        return handleStreamError(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) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            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 workflow = client.getWorkflow(workflowId);
+      const requestContext$1 = new requestContext.RequestContext();
+      Object.entries(playgroundRequestContext).forEach(([key, value]) => {
+        requestContext$1.set(key, value);
+      });
+      const run = await workflow.createRun({ runId });
+      const stream = await run.timeTravelStream({
+        ...params,
+        perStep: perStep ?? debugMode,
+        requestContext: requestContext$1,
+        tracingOptions
+      });
+      if (!stream) {
+        return handleStreamError(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) => {
+              const newResult = mapWorkflowStreamChunkToWatchResult(prev, value);
+              return newResult;
+            });
+            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;
+        }
+      }
+    }
+  );
+  const closeStreamsAndReset = react.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;
+    }
+  }, []);
+  return {
+    streamWorkflow,
+    streamResult,
+    isStreaming,
+    observeWorkflowStream,
+    closeStreamsAndReset,
+    resumeWorkflowStream,
+    timeTravelWorkflowStream
+  };
+}
+
+// src/workflows/hooks.ts
+function useCreateWorkflowRun() {
+  const client = useMastraClient();
+  return useMutation(async ({ workflowId, prevRunId }) => {
+    try {
+      const workflow = client.getWorkflow(workflowId);
+      const { runId: newRunId } = await workflow.createRun({ runId: prevRunId });
+      return { runId: newRunId };
+    } catch (error) {
+      console.error("Error creating workflow run:", error);
+      throw error;
+    }
+  });
+}
+function useCancelWorkflowRun() {
+  const client = useMastraClient();
+  return useMutation(async ({ workflowId, runId }) => {
+    try {
+      const workflow = client.getWorkflow(workflowId);
+      const run = await workflow.createRun({ runId });
+      return run.cancelRun();
+    } catch (error) {
+      console.error("Error canceling workflow run:", error);
+      throw error;
+    }
+  });
+}
+
+exports.AgentIcon = AgentIcon;
+exports.CodeBlock = CodeBlock;
+exports.CodeBlockClass = CodeBlockClass;
+exports.CodeCopyButton = CodeCopyButton;
+exports.Entity = Entity;
+exports.EntityCaret = EntityCaret;
+exports.EntityContent = EntityContent;
+exports.EntityContentClass = EntityContentClass;
+exports.EntityTrigger = EntityTrigger;
+exports.EntityTriggerClass = EntityTriggerClass;
+exports.EntityTriggerVariantClasses = EntityTriggerVariantClasses;
+exports.Entry = Entry;
+exports.EntryClass = EntryClass;
+exports.EntryTitle = EntryTitle;
+exports.EntryTitleClass = EntryTitleClass;
+exports.Icon = Icon;
+exports.IconButton = IconButton;
+exports.IconButtonClass = IconButtonClass;
+exports.IconSizes = IconSizes;
+exports.MastraReactProvider = MastraReactProvider;
+exports.Message = Message;
+exports.MessageActions = MessageActions;
+exports.MessageActionsClass = MessageActionsClass;
+exports.MessageClass = MessageClass;
+exports.MessageContent = MessageContent;
+exports.MessageContentClass = MessageContentClass;
+exports.MessageList = MessageList;
+exports.MessageListClass = MessageListClass;
+exports.MessageStreaming = MessageStreaming;
+exports.MessageStreamingClass = MessageStreamingClass;
+exports.MessageUsage = MessageUsage;
+exports.MessageUsageClass = MessageUsageClass;
+exports.MessageUsageEntry = MessageUsageEntry;
+exports.MessageUsageEntryClass = MessageUsageEntryClass;
+exports.MessageUsageValue = MessageUsageValue;
+exports.MessageUsageValueClass = MessageUsageValueClass;
+exports.MessageUsages = MessageUsages;
+exports.MessageUsagesClass = MessageUsagesClass;
+exports.ToolApproval = ToolApproval;
+exports.ToolApprovalActions = ToolApprovalActions;
+exports.ToolApprovalActionsClass = ToolApprovalActionsClass;
+exports.ToolApprovalClass = ToolApprovalClass;
+exports.ToolApprovalContent = ToolApprovalContent;
+exports.ToolApprovalContentClass = ToolApprovalContentClass;
+exports.ToolApprovalHeader = ToolApprovalHeader;
+exports.ToolApprovalHeaderClass = ToolApprovalHeaderClass;
+exports.ToolApprovalTitle = ToolApprovalTitle;
+exports.ToolApprovalTitleClass = ToolApprovalTitleClass;
+exports.ToolsIcon = ToolsIcon;
+exports.Tooltip = Tooltip;
+exports.TooltipContent = TooltipContent;
+exports.TooltipContentClass = TooltipContentClass;
+exports.TooltipTrigger = TooltipTrigger;
+exports.WorkflowIcon = WorkflowIcon;
+exports.mapWorkflowStreamChunkToWatchResult = mapWorkflowStreamChunkToWatchResult;
+exports.resolveToChildMessages = resolveToChildMessages;
+exports.toAssistantUIMessage = toAssistantUIMessage;
+exports.toUIMessage = toUIMessage;
+exports.useCancelWorkflowRun = useCancelWorkflowRun;
+exports.useChat = useChat;
+exports.useCreateWorkflowRun = useCreateWorkflowRun;
+exports.useEntity = useEntity;
+exports.useMastraClient = useMastraClient;
+exports.useStreamWorkflow = useStreamWorkflow;
 //# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map