@mastra/react 0.0.0-model-router-unknown-provider-20251017212006 → 0.0.0-playground-studio-cloud-20251031080052

package/dist/index.js

@@ -1,7 +1,6 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { createContext, useContext, useState, Fragment, useLayoutEffect, useRef, useEffect } from 'react';
+import { createContext, useContext, useRef, useState, Fragment, useLayoutEffect, useEffect } from 'react';
 import { MastraClient } from '@mastra/client-js';
-import { flushSync } from 'react-dom';
 import { ChevronDownIcon, CheckIcon, CopyIcon } from 'lucide-react';
 import { twMerge } from 'tailwind-merge';
 import { toJsxRuntime } from 'hast-util-to-jsx-runtime';
@@ -250,6 +249,7 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
         }
       ];
     }
+    case "tool-error":
     case "tool-result": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
@@ -260,25 +260,35 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
       if (toolPartIndex !== -1) {
         const toolPart = parts[toolPartIndex];
         if (toolPart.type === "dynamic-tool") {
-          if (chunk.payload.isError) {
+          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,
               state: "output-error",
               input: toolPart.input,
-              errorText: String(chunk.payload.result),
+              errorText: 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,
               state: "output-available",
               input: toolPart.input,
-              output: isWorkflow ? chunk.payload.result?.result : chunk.payload.result,
+              output,
               callProviderMetadata: chunk.payload.providerMetadata
             };
           }
@@ -312,6 +322,8 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
               ...toolPart,
               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);
           } else {
             const currentOutput = toolPart.output || [];
             const existingOutput = Array.isArray(currentOutput) ? currentOutput : [];
@@ -385,6 +397,29 @@ 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.toolCallId]: {
+                toolCallId: chunk.payload.toolCallId,
+                toolName: chunk.payload.toolName,
+                args: chunk.payload.args
+              }
+            }
+          }
+        }
+      ];
+    }
     case "finish": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
@@ -427,6 +462,105 @@ const toUIMessage = ({ chunk, conversation, metadata }) => {
       return result;
   }
 };
+const toUIMessageFromAgent = (chunk, conversation, metadata) => {
+  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");
+    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");
+    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");
+    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");
+    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) => {
   const extendedMessage = message;
@@ -466,13 +600,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 = {
@@ -547,6 +691,110 @@ const toAssistantUIMessage = (message) => {
   return threadMessage;
 };
 
+const resolveInitialMessages = (messages) => {
+  return messages.map((message) => {
+    const networkPart = message.parts.find((part) => part.type === "text" && part.text.includes('"isNetwork":true'));
+    if (networkPart && networkPart.type === "text") {
+      try {
+        const json = JSON.parse(networkPart.text);
+        if (json.isNetwork === true) {
+          const selectionReason = json.selectionReason || "";
+          const primitiveType = json.primitiveType || "";
+          const primitiveId = json.primitiveId || "";
+          const finalResult = json.finalResult;
+          const toolCalls = finalResult?.toolCalls || [];
+          const childMessages = [];
+          for (const toolCall of toolCalls) {
+            if (toolCall.type === "tool-call" && toolCall.payload) {
+              const toolCallId = toolCall.payload.toolCallId;
+              let toolResult;
+              for (const message2 of finalResult?.messages || []) {
+                for (const part of message2.content || []) {
+                  if (typeof part === "object" && part.type === "tool-result" && part.toolCallId === toolCallId) {
+                    toolResult = part;
+                    break;
+                  }
+                }
+              }
+              const isWorkflow = Boolean(toolResult?.result?.result?.steps);
+              childMessages.push({
+                type: "tool",
+                toolCallId: toolCall.payload.toolCallId,
+                toolName: toolCall.payload.toolName,
+                args: toolCall.payload.args,
+                toolOutput: isWorkflow ? toolResult?.result?.result : toolResult?.result
+              });
+            }
+          }
+          if (finalResult && finalResult.text) {
+            childMessages.push({
+              type: "text",
+              content: finalResult.text
+            });
+          }
+          const result = {
+            childMessages,
+            result: finalResult?.text || ""
+          };
+          console.log("json", json);
+          const nextMessage = {
+            role: "assistant",
+            parts: [
+              {
+                type: "dynamic-tool",
+                toolCallId: primitiveId,
+                toolName: primitiveId,
+                state: "output-available",
+                input: json.input,
+                output: result
+              }
+            ],
+            id: message.id,
+            metadata: {
+              ...message.metadata,
+              mode: "network",
+              selectionReason,
+              agentInput: json.input,
+              from: primitiveType === "agent" ? "AGENT" : "WORKFLOW"
+            }
+          };
+          return nextMessage;
+        }
+      } catch (error) {
+        return message;
+      }
+    }
+    return message;
+  });
+};
+const 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;
+};
+
 class AISdkNetworkTransformer {
   transform({ chunk, conversation, metadata }) {
     const newConversation = [...conversation];
@@ -919,87 +1167,58 @@ class AISdkNetworkTransformer {
   };
 }
 
-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;
+const 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 _currentRunId = useRef(void 0);
+  const _onChunk = useRef(void 0);
   const [messages, setMessages] = useState(
     () => resolveInitialMessages(initializeMessages?.() || [])
   );
+  const [toolCallApprovals, setToolCallApprovals] = useState({});
   const baseClient = useMastraClient();
   const [isRunning, setIsRunning] = useState(false);
   const generate = async ({
@@ -1069,7 +1288,8 @@ const useChat = ({ agentId, initializeMessages }) => {
       topP,
       instructions,
       providerOptions,
-      maxSteps
+      maxSteps,
+      requireToolApproval
     } = modelSettings || {};
     setIsRunning(true);
     const clientWithAbort = new MastraClient({
@@ -1077,9 +1297,10 @@ const useChat = ({ agentId, initializeMessages }) => {
       abortSignal: signal
     });
     const agent = clientWithAbort.getAgent(agentId);
+    const runId = agentId;
     const response = await agent.stream({
       messages: coreUserMessages,
-      runId: agentId,
+      runId,
       maxSteps,
       modelSettings: {
         frequencyPenalty,
@@ -1093,17 +1314,14 @@ const useChat = ({ agentId, initializeMessages }) => {
       instructions,
       runtimeContext,
       ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
+      providerOptions,
+      requireToolApproval
     });
-    if (!response.body) {
-      setIsRunning(false);
-      throw new Error("[Stream] No response body");
-    }
+    _onChunk.current = onChunk;
+    _currentRunId.current = runId;
     await response.processDataStream({
       onChunk: async (chunk) => {
-        flushSync(() => {
-          setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
-        });
+        setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
         onChunk?.(chunk);
       }
     });
@@ -1143,24 +1361,65 @@ const useChat = ({ agentId, initializeMessages }) => {
     const transformer = new AISdkNetworkTransformer();
     await response.processDataStream({
       onChunk: async (chunk) => {
-        flushSync(() => {
-          setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
-        });
+        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
         onNetworkChunk?.(chunk);
       }
     });
     setIsRunning(false);
   };
+  const handleCancelRun = () => {
+    setIsRunning(false);
+    _currentRunId.current = void 0;
+    _onChunk.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" } }));
+        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" } }));
+        onChunk?.(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 {
@@ -1168,7 +1427,10 @@ const useChat = ({ agentId, initializeMessages }) => {
     sendMessage,
     isRunning,
     messages,
-    cancelRun: () => setIsRunning(false)
+    approveToolCall,
+    declineToolCall,
+    cancelRun: handleCancelRun,
+    toolCallApprovals
   };
 };
 
@@ -1487,5 +1749,5 @@ const MessageStreaming = ({ className, ...props }) => {
   return /* @__PURE__ */ jsx("span", { className: className || MessageStreamingClass, ...props });
 };
 
-export { AgentIcon, CodeBlock, CodeBlockClass, CodeCopyButton, Entity, EntityCaret, EntityContent, EntityContentClass, EntityTrigger, EntityTriggerClass, EntityTriggerVariantClasses, Entry, EntryClass, EntryTitle, EntryTitleClass, Icon, IconButton, IconButtonClass, IconSizes, MastraReactProvider, Message, MessageActions, MessageActionsClass, MessageClass, MessageContent, MessageContentClass, MessageList, MessageListClass, MessageStreaming, MessageStreamingClass, MessageUsage, MessageUsageClass, MessageUsageEntry, MessageUsageEntryClass, MessageUsageValue, MessageUsageValueClass, MessageUsages, MessageUsagesClass, ToolApproval, ToolApprovalActions, ToolApprovalActionsClass, ToolApprovalClass, ToolApprovalContent, ToolApprovalContentClass, ToolApprovalHeader, ToolApprovalHeaderClass, ToolApprovalTitle, ToolApprovalTitleClass, ToolsIcon, Tooltip, TooltipContent, TooltipContentClass, TooltipTrigger, WorkflowIcon, mapWorkflowStreamChunkToWatchResult, toAssistantUIMessage, toUIMessage, useChat, useEntity, useMastraClient };
+export { AgentIcon, CodeBlock, CodeBlockClass, CodeCopyButton, Entity, EntityCaret, EntityContent, EntityContentClass, EntityTrigger, EntityTriggerClass, EntityTriggerVariantClasses, Entry, EntryClass, EntryTitle, EntryTitleClass, Icon, IconButton, IconButtonClass, IconSizes, MastraReactProvider, Message, MessageActions, MessageActionsClass, MessageClass, MessageContent, MessageContentClass, MessageList, MessageListClass, MessageStreaming, MessageStreamingClass, MessageUsage, MessageUsageClass, MessageUsageEntry, MessageUsageEntryClass, MessageUsageValue, MessageUsageValueClass, MessageUsages, MessageUsagesClass, ToolApproval, ToolApprovalActions, ToolApprovalActionsClass, ToolApprovalClass, ToolApprovalContent, ToolApprovalContentClass, ToolApprovalHeader, ToolApprovalHeaderClass, ToolApprovalTitle, ToolApprovalTitleClass, ToolsIcon, Tooltip, TooltipContent, TooltipContentClass, TooltipTrigger, WorkflowIcon, mapWorkflowStreamChunkToWatchResult, resolveToChildMessages, toAssistantUIMessage, toUIMessage, useChat, useEntity, useMastraClient };
 //# sourceMappingURL=index.js.map