@mastra/react 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/dist/index.cjs

@@ -1,35 +1,50 @@
 '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 jsxRuntime = require('react/jsx-runtime');
-const react = require('react');
-const clientJs = require('@mastra/client-js');
-const lucideReact = require('lucide-react');
-const tailwindMerge = require('tailwind-merge');
-const hastUtilToJsxRuntime = require('hast-util-to-jsx-runtime');
-const web = require('shiki/bundle/web');
-const reactTooltip = require('@radix-ui/react-tooltip');
-
-const MastraClientContext = react.createContext({});
-const MastraClientProvider = ({ children, baseUrl, headers }) => {
-  const client = createMastraClient(baseUrl, headers);
+// 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 });
 };
-const useMastraClient = () => react.useContext(MastraClientContext);
-const createMastraClient = (baseUrl, mastraClientHeaders = {}) => {
+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 || "",
-    // only add the header if the baseUrl is not provided i.e it's a local dev environment
-    headers: !baseUrl ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders
+    headers: isLocalUrl(baseUrl) ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders,
+    apiPrefix
   });
 };
-
-const MastraReactProvider = ({ children, baseUrl, headers }) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, children });
+var MastraReactProvider = ({ children, baseUrl, headers, apiPrefix }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, apiPrefix, children });
 };
-
-const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
   if (chunk.type === "workflow-start") {
     return {
       input: prev?.input,
@@ -50,7 +65,7 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
     return {
       ...prev,
       status: chunk.payload.workflowStatus,
-      ...finalStatus === "success" && lastStep?.status === "success" ? { result: lastStep?.output } : finalStatus === "failed" && lastStep?.status === "failed" ? { error: lastStep?.error } : {}
+      ...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 ?? {};
@@ -92,6 +107,25 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
       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,
@@ -100,8 +134,36 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
   }
   return prev;
 };
-const toUIMessage = ({ chunk, conversation, metadata }) => {
+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 = {
@@ -110,57 +172,90 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
         parts: [
           {
             type: "text",
-            text: chunk.payload.tripwireReason
+            text: chunk.payload.reason
           }
         ],
         metadata: {
           ...metadata,
-          status: "warning"
+          status: "tripwire",
+          tripwire: {
+            retry: chunk.payload.retry,
+            tripwirePayload: chunk.payload.metadata,
+            processorId: chunk.payload.processorId
+          }
         }
       };
       return [...result, newMessage];
     }
     case "start": {
       const newMessage = {
-        id: `start-${chunk.runId + Date.now()}`,
+        id: typeof chunk.payload.messageId === "string" ? chunk.payload.messageId : `start-${chunk.runId + Date.now()}`,
         role: "assistant",
         parts: [],
         metadata
       };
       return [...result, newMessage];
     }
-    case "text-start":
-    case "text-delta": {
+    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];
-      let textPartIndex = parts.findIndex((part) => part.type === "text");
-      if (chunk.type === "text-start") {
-        if (textPartIndex === -1) {
-          parts.push({
-            type: "text",
-            text: "",
-            state: "streaming",
-            providerMetadata: chunk.payload.providerMetadata
-          });
+      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 {
-        if (textPartIndex === -1) {
-          parts.push({
-            type: "text",
-            text: chunk.payload.text,
-            state: "streaming",
-            providerMetadata: chunk.payload.providerMetadata
-          });
-        } else {
-          const textPart = parts[textPartIndex];
-          if (textPart.type === "text") {
-            parts[textPartIndex] = {
-              ...textPart,
-              text: textPart.text + chunk.payload.text,
-              state: "streaming"
-            };
-          }
+        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 [
@@ -253,35 +348,48 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
         }
       ];
     }
+    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" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+        (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") {
-          if (chunk.payload.isError) {
+        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: toolPart.toolName,
-              toolCallId: toolPart.toolCallId,
+              toolName,
+              toolCallId,
               state: "output-error",
               input: toolPart.input,
-              errorText: String(chunk.payload.result),
+              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: toolPart.toolName,
-              toolCallId: toolPart.toolCallId,
+              toolName,
+              toolCallId,
               state: "output-available",
               input: toolPart.input,
-              output: isWorkflow ? chunk.payload.result?.result : chunk.payload.result,
+              output,
               callProviderMetadata: chunk.payload.providerMetadata
             };
           }
@@ -300,11 +408,14 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
       if (!lastMessage || lastMessage.role !== "assistant") return result;
       const parts = [...lastMessage.parts];
       const toolPartIndex = parts.findIndex(
-        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+        (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") {
+        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(
@@ -312,14 +423,24 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
               chunk.payload.output
             );
             parts[toolPartIndex] = {
-              ...toolPart,
+              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] = {
-              ...toolPart,
+              type: "dynamic-tool",
+              toolName,
+              toolCallId,
+              state: "input-streaming",
+              input,
               output: [...existingOutput, chunk.payload.output]
             };
           }
@@ -333,6 +454,36 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
         }
       ];
     }
+    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;
@@ -388,15 +539,61 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
         }
       ];
     }
+    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 (part.type === "text" && part.state === "streaming") {
-          return { ...part, state: "done" };
-        }
-        if (part.type === "reasoning" && part.state === "streaming") {
-          return { ...part, state: "done" };
+        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;
       });
@@ -430,8 +627,116 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
       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
+    }
+  ];
+};
 
-const toAssistantUIMessage = (message) => {
+// src/lib/ai-sdk/utils/toAssistantUIMessage.ts
+var toAssistantUIMessage = (message) => {
   const extendedMessage = message;
   const content = message.parts.map((part) => {
     if (part.type === "text") {
@@ -469,13 +774,23 @@ const toAssistantUIMessage = (message) => {
       };
     }
     if (part.type === "file") {
-      return {
-        type: "file",
-        mimeType: part.mediaType,
-        data: part.url,
-        // Use URL as data source
-        metadata: message.metadata
-      };
+      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 = {
@@ -495,13 +810,14 @@ const toAssistantUIMessage = (message) => {
       return baseToolCall;
     }
     if (part.type.startsWith("tool-") && part.state !== "input-available") {
-      const toolName = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.substring(5);
+      const 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,
-        argsText: "input" in part ? JSON.stringify(part.input) : "{}",
-        args: "input" in part ? part.input : {},
+        toolName: toolName2,
+        argsText: JSON.stringify(cleanInput ?? {}),
+        args: cleanInput ?? {},
         metadata: message.metadata
       };
       if ("output" in part) {
@@ -511,6 +827,31 @@ const toAssistantUIMessage = (message) => {
       }
       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: "",
@@ -550,7 +891,153 @@ const toAssistantUIMessage = (message) => {
   return threadMessage;
 };
 
-class AISdkNetworkTransformer {
+// 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") {
@@ -565,12 +1052,43 @@ class AISdkNetworkTransformer {
     if (chunk.type.startsWith("tool-execution-")) {
       return this.handleToolConversation(chunk, newConversation, metadata);
     }
-    if (chunk.type === "network-execution-event-step-finish") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const agentChunk = chunk.payload;
-      const parts = [...lastMessage.parts];
-      const textPartIndex = parts.findIndex((part) => part.type === "text");
+    if (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",
@@ -667,6 +1185,54 @@ class AISdkNetworkTransformer {
       };
       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;
@@ -797,7 +1363,7 @@ class AISdkNetworkTransformer {
       let agentInput;
       try {
         agentInput = JSON.parse(chunk?.payload?.args?.prompt);
-      } catch (e) {
+      } catch {
         agentInput = chunk?.payload?.args?.prompt;
       }
       const newMessage = {
@@ -822,6 +1388,30 @@ class AISdkNetworkTransformer {
       };
       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;
@@ -889,6 +1479,54 @@ class AISdkNetworkTransformer {
         }
       ];
     }
+    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;
@@ -920,98 +1558,90 @@ class AISdkNetworkTransformer {
     }
     return newConversation;
   };
-}
+};
 
-const resolveInitialMessages = (messages) => {
-  return messages.map((message) => {
-    const networkPart = message.parts.find((part) => part.type === "text" && part.text.includes('"isNetwork":true'));
-    if (networkPart && networkPart.type === "text") {
-      try {
-        const json = JSON.parse(networkPart.text);
-        if (json.isNetwork === true) {
-          const selectionReason = json.selectionReason || "";
-          const primitiveType = json.primitiveType || "";
-          const primitiveId = json.primitiveId || "";
-          const finalResult = json.finalResult;
-          const toolCalls = finalResult?.toolCalls || [];
-          const childMessages = [];
-          for (const toolCall of toolCalls) {
-            if (toolCall.type === "tool-call" && toolCall.payload) {
-              const toolCallId = toolCall.payload.toolCallId;
-              let toolResult;
-              for (const message2 of finalResult?.messages || []) {
-                for (const part of message2.content || []) {
-                  if (typeof part === "object" && part.type === "tool-result" && part.toolCallId === toolCallId) {
-                    toolResult = part;
-                    break;
-                  }
-                }
-              }
-              const isWorkflow = Boolean(toolResult?.result?.result?.steps);
-              childMessages.push({
-                type: "tool",
-                toolCallId: toolCall.payload.toolCallId,
-                toolName: toolCall.payload.toolName,
-                args: toolCall.payload.args,
-                toolOutput: isWorkflow ? toolResult?.result?.result : toolResult?.result
-              });
-            }
-          }
-          if (finalResult && finalResult.text) {
-            childMessages.push({
-              type: "text",
-              content: finalResult.text
-            });
-          }
-          const result = {
-            childMessages,
-            result: finalResult?.text || ""
-          };
-          console.log("json", json);
-          const nextMessage = {
-            role: "assistant",
-            parts: [
-              {
-                type: "dynamic-tool",
-                toolCallId: primitiveId,
-                toolName: primitiveId,
-                state: "output-available",
-                input: json.input,
-                output: result
-              }
-            ],
-            id: message.id,
-            metadata: {
-              ...message.metadata,
-              mode: "network",
-              selectionReason,
-              agentInput: json.input,
-              from: primitiveType === "agent" ? "AGENT" : "WORKFLOW"
-            }
-          };
-          return nextMessage;
-        }
-      } catch (error) {
-        return message;
+// 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 message;
   });
+  return {
+    id,
+    role: "user",
+    parts
+  };
 };
 
-const useChat = ({ agentId, initializeMessages }) => {
-  const [messages, setMessages] = react.useState(
-    () => resolveInitialMessages(initializeMessages?.() || [])
-  );
+// 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,
-    runtimeContext,
+    requestContext,
     threadId,
     modelSettings,
     signal,
-    onFinish
+    onFinish,
+    tracingOptions
   }) => {
     const {
       frequencyPenalty,
@@ -1023,7 +1653,8 @@ const useChat = ({ agentId, initializeMessages }) => {
       topP,
       instructions,
       providerOptions,
-      maxSteps
+      maxSteps,
+      requireToolApproval
     } = modelSettings || {};
     setIsRunning(true);
     const clientWithAbort = new clientJs.MastraClient({
@@ -1031,9 +1662,10 @@ const useChat = ({ agentId, initializeMessages }) => {
       abortSignal: signal
     });
     const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.generate({
-      messages: coreUserMessages,
-      runId: agentId,
+    const runId = uuid.v4();
+    _currentRunId.current = runId;
+    const response = await agent.generate(coreUserMessages, {
+      runId,
       maxSteps,
       modelSettings: {
         frequencyPenalty,
@@ -1045,13 +1677,36 @@ const useChat = ({ agentId, initializeMessages }) => {
         topP
       },
       instructions,
-      runtimeContext,
-      ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
+      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) {
-      onFinish?.(response.response.uiMessages);
+      void onFinish?.(response.response.uiMessages);
       const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
         ...message,
         metadata: {
@@ -1061,7 +1716,15 @@ const useChat = ({ agentId, initializeMessages }) => {
       setMessages((prev) => [...prev, ...mastraUIMessages]);
     }
   };
-  const stream = async ({ coreUserMessages, runtimeContext, threadId, onChunk, modelSettings, signal }) => {
+  const stream = async ({
+    coreUserMessages,
+    requestContext,
+    threadId,
+    onChunk,
+    modelSettings,
+    signal,
+    tracingOptions
+  }) => {
     const {
       frequencyPenalty,
       presencePenalty,
@@ -1072,7 +1735,8 @@ const useChat = ({ agentId, initializeMessages }) => {
       topP,
       instructions,
       providerOptions,
-      maxSteps
+      maxSteps,
+      requireToolApproval
     } = modelSettings || {};
     setIsRunning(true);
     const clientWithAbort = new clientJs.MastraClient({
@@ -1080,9 +1744,9 @@ const useChat = ({ agentId, initializeMessages }) => {
       abortSignal: signal
     });
     const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.stream({
-      messages: coreUserMessages,
-      runId: agentId,
+    const runId = uuid.v4();
+    const response = await agent.stream(coreUserMessages, {
+      runId,
       maxSteps,
       modelSettings: {
         frequencyPenalty,
@@ -1094,29 +1758,30 @@ const useChat = ({ agentId, initializeMessages }) => {
         topP
       },
       instructions,
-      runtimeContext,
-      ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
+      requestContext,
+      ...threadId ? { memory: { thread: threadId, resource: resourceId || agentId } } : {},
+      providerOptions,
+      requireToolApproval,
+      tracingOptions
     });
-    if (!response.body) {
-      setIsRunning(false);
-      throw new Error("[Stream] No response body");
-    }
+    _onChunk.current = onChunk;
+    _currentRunId.current = runId;
     await response.processDataStream({
       onChunk: async (chunk) => {
         setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
-        onChunk?.(chunk);
+        void onChunk?.(chunk);
       }
     });
     setIsRunning(false);
   };
   const network = async ({
     coreUserMessages,
-    runtimeContext,
+    requestContext,
     threadId,
     onNetworkChunk,
     modelSettings,
-    signal
+    signal,
+    tracingOptions
   }) => {
     const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
     setIsRunning(true);
@@ -1125,8 +1790,8 @@ const useChat = ({ agentId, initializeMessages }) => {
       abortSignal: signal
     });
     const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.network({
-      messages: coreUserMessages,
+    const runId = uuid.v4();
+    const response = await agent.network(coreUserMessages, {
       maxSteps,
       modelSettings: {
         frequencyPenalty,
@@ -1137,29 +1802,165 @@ const useChat = ({ agentId, initializeMessages }) => {
         topK,
         topP
       },
-      runId: agentId,
-      runtimeContext,
-      ...threadId ? { thread: threadId, resourceId: agentId } : {}
+      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" } }));
-        onNetworkChunk?.(chunk);
+        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 messages2 = args.coreUserMessages ? [nextMessage, ...args.coreUserMessages] : [nextMessage];
-    setMessages((s) => [...s, { role: "user", parts: [{ 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: messages2 });
+      await generate({ ...args, coreUserMessages });
     } else if (mode === "stream") {
-      await stream({ ...args, coreUserMessages: messages2 });
+      await stream({ ...args, coreUserMessages });
     } else if (mode === "network") {
-      await network({ ...args, coreUserMessages: messages2 });
+      await network({ ...args, coreUserMessages });
     }
   };
   return {
@@ -1167,30 +1968,35 @@ const useChat = ({ agentId, initializeMessages }) => {
     sendMessage,
     isRunning,
     messages,
-    cancelRun: () => setIsRunning(false)
+    approveToolCall,
+    declineToolCall,
+    approveToolCallGenerate,
+    declineToolCallGenerate,
+    cancelRun: handleCancelRun,
+    toolCallApprovals,
+    approveNetworkToolCall,
+    declineNetworkToolCall,
+    networkToolCallApprovals
   };
 };
-
-const EntityContext = react.createContext({
-  expanded: false,
-  setExpanded: () => {
-  },
-  variant: "initial",
-  disabled: false
-});
-const EntityProvider = EntityContext.Provider;
-const useEntity = () => react.useContext(EntityContext);
-
-const IconSizes = {
+var IconSizes = {
   sm: "mastra:[&>svg]:size-3",
   md: "mastra:[&>svg]:size-4",
   lg: "mastra:[&>svg]:size-5"
 };
-const Icon = ({ children, className, size = "md", ...props }) => {
+var Icon = ({ children, className, size = "md", ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || IconSizes[size], ...props, children });
 };
-
-const Entity = ({
+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,
@@ -1200,21 +2006,21 @@ const Entity = ({
   const [expanded, setExpanded] = react.useState(initialExpanded);
   return /* @__PURE__ */ jsxRuntime.jsx(EntityProvider, { value: { expanded, setExpanded, variant, disabled }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className, ...props }) });
 };
-const EntityTriggerClass = tailwindMerge.twMerge(
+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"
 );
-const EntityTriggerVariantClasses = {
+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"
 };
-const EntityTrigger = ({ className, children, ...props }) => {
+var EntityTrigger = ({ className, children, ...props }) => {
   const { expanded, setExpanded, variant, disabled } = useEntity();
   const handleClick = (e) => {
     if (disabled) return;
@@ -1233,17 +2039,17 @@ const EntityTrigger = ({ className, children, ...props }) => {
     }
   );
 };
-const EntityContentClass = tailwindMerge.twMerge(
+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"
 );
-const EntityContent = ({ className, ...props }) => {
+var EntityContent = ({ className, ...props }) => {
   const { expanded } = useEntity();
   if (!expanded) return null;
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || EntityContentClass, ...props });
 };
-const EntityCaret = ({ className, ...props }) => {
+var EntityCaret = ({ className, ...props }) => {
   const { expanded } = useEntity();
   return /* @__PURE__ */ jsxRuntime.jsx(Icon, { children: /* @__PURE__ */ jsxRuntime.jsx(
     lucideReact.ChevronDownIcon,
@@ -1257,68 +2063,52 @@ const EntityCaret = ({ className, ...props }) => {
     }
   ) });
 };
-
-const ToolApprovalClass = tailwindMerge.twMerge(
+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"
 );
-const ToolApproval = ({ className, ...props }) => {
+var ToolApproval = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalClass, ...props });
 };
-const ToolApprovalTitleClass = tailwindMerge.twMerge("mastra:text-text6 mastra:inline-flex mastra:items-center mastra:gap-1");
-const ToolApprovalTitle = ({ className, ...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 });
 };
-const ToolApprovalHeaderClass = tailwindMerge.twMerge(
+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"
 );
-const ToolApprovalHeader = ({ className, ...props }) => {
+var ToolApprovalHeader = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalHeaderClass, ...props });
 };
-const ToolApprovalContentClass = tailwindMerge.twMerge("mastra:text-text6 mastra:p-4");
-const ToolApprovalContent = ({ className, ...props }) => {
+var ToolApprovalContentClass = tailwindMerge.twMerge("mastra:text-text6 mastra:p-4");
+var ToolApprovalContent = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || ToolApprovalContentClass, ...props });
 };
-const ToolApprovalActionsClass = tailwindMerge.twMerge("mastra:flex mastra:gap-2 mastra:items-center");
-const ToolApprovalActions = ({ className, ...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 });
 };
-
-const EntryClass = "mastra:space-y-2";
-const Entry = ({ className, ...props }) => {
+var EntryClass = "mastra:space-y-2";
+var Entry = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || EntryClass, ...props });
 };
-const EntryTitleClass = "mastra:font-mono mastra:text-sm mastra:text-text3";
-const EntryTitle = ({ className, as: Root = "h3", ...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 });
 };
-
-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
-  });
-}
-
-const Tooltip = ({ children }) => {
+var Tooltip = ({ children }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.Root, { children }) });
 };
-const TooltipContentClass = "mastra:bg-surface4 mastra:text-text6 mastra mastra:rounded-lg mastra:py-1 mastra:px-2 mastra:text-xs mastra:border mastra:border-border1 mastra-tooltip-enter";
-const TooltipContent = ({ children, className, ...props }) => {
+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 }) });
 };
-const TooltipTrigger = (props) => {
+var TooltipTrigger = (props) => {
   return /* @__PURE__ */ jsxRuntime.jsx(reactTooltip.TooltipTrigger, { ...props, asChild: true });
 };
-
-const IconButtonClass = "mastra:text-text3 mastra:hover:text-text6 mastra:active:text-text6 mastra:hover:bg-surface4 mastra:active:bg-surface5 mastra:rounded-md mastra:cursor-pointer";
-const IconButton = ({ children, tooltip, size = "md", className, ...props }) => {
+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",
@@ -1331,9 +2121,19 @@ const IconButton = ({ children, tooltip, size = "md", className, ...props }) =>
     /* @__PURE__ */ jsxRuntime.jsx(TooltipContent, { children: tooltip })
   ] });
 };
-
-const CodeBlockClass = "mastra:rounded-lg mastra:[&>pre]:p-4 mastra:overflow-hidden mastra:[&>pre]:!bg-surface4 mastra:[&>pre>code]:leading-5 mastra:relative";
-const CodeBlock = ({ code, language, className, cta }) => {
+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);
@@ -1343,17 +2143,16 @@ const CodeBlock = ({ code, language, className, cta }) => {
     cta
   ] });
 };
-const CodeCopyButton = ({ code }) => {
+var CodeCopyButton = ({ code }) => {
   const [isCopied, setIsCopied] = react.useState(false);
   const handleCopy = () => {
-    navigator.clipboard.writeText(code);
+    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, {}) }) });
 };
-
-const AgentIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsxs(
+var AgentIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsxs(
   "svg",
   {
     width: "17",
@@ -1383,8 +2182,7 @@ const AgentIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsxs(
     ]
   }
 );
-
-const ToolsIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+var ToolsIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
   "svg",
   {
     width: "17",
@@ -1405,8 +2203,7 @@ const ToolsIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
     )
   }
 );
-
-const WorkflowIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+var WorkflowIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
   "svg",
   {
     width: "17",
@@ -1427,9 +2224,8 @@ const WorkflowIcon = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx
     )
   }
 );
-
-const MessageClass = "mastra:flex mastra:flex-col mastra:w-full mastra:py-4 mastra:gap-2 mastra:group";
-const Message = ({ position, className, children, ...props }) => {
+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",
     {
@@ -1442,35 +2238,35 @@ const Message = ({ position, className, children, ...props }) => {
     }
   );
 };
-const MessageContentClass = "mastra:max-w-4/5 mastra:py-2 mastra:text-text6 mastra:rounded-lg mastra-message-content mastra:text-md";
-const MessageContent = ({ children, className, isStreaming, ...props }) => {
+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, {})
   ] });
 };
-const MessageActionsClass = "mastra:gap-2 mastra:flex mastra:opacity-0 mastra:group-hover:opacity-100 mastra:group-focus-within:opacity-100 mastra:items-center";
-const MessageActions = ({ children, className, ...props }) => {
+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 });
 };
-const MessageUsagesClass = "mastra:flex mastra:gap-2 mastra:items-center";
-const MessageUsages = ({ children, className, ...props }) => {
+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 });
 };
-const MessageUsageClass = "mastra:flex mastra:gap-2 mastra:items-center mastra:font-mono mastra:text-xs mastra:bg-surface3 mastra:rounded-lg mastra:px-2 mastra:py-1";
-const MessageUsage = ({ children, className, ...props }) => {
+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 });
 };
-const MessageUsageEntryClass = "mastra:text-text3 mastra:text-xs mastra:flex mastra:gap-1 mastra:items-center";
-const MessageUsageEntry = ({ children, className, ...props }) => {
+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 });
 };
-const MessageUsageValueClass = "mastra:text-text6 mastra:text-xs";
-const MessageUsageValue = ({ children, className, ...props }) => {
+var MessageUsageValueClass = "mastra:text-text6 mastra:text-xs";
+var MessageUsageValue = ({ children, className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("dd", { className: className || MessageUsageValueClass, ...props, children });
 };
-const MessageListClass = "mastra:overflow-y-auto mastra:h-full mastra-list";
-const MessageList = ({ children, className, ...props }) => {
+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 = () => {
@@ -1481,10 +2277,431 @@ const MessageList = ({ children, className, ...props }) => {
   });
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className || MessageListClass, ...props, ref: listRef, children });
 };
-const MessageStreamingClass = "mastra:inline-block mastra:w-[2px] mastra:h-[1em] mastra:bg-text5 mastra:ml-0.5 mastra:align-text-bottom mastra:animate-pulse";
-const MessageStreaming = ({ className, ...props }) => {
+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;
@@ -1541,9 +2758,14 @@ 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