@mastra/react 0.0.0-ai-sdk-workflow-route-20251010135341

package/dist/index.es.js

@@ -0,0 +1,1100 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useState } from 'react';
+import { MastraClient } from '@mastra/client-js';
+import { flushSync } from 'react-dom';
+
+const MastraClientContext = createContext({});
+const MastraClientProvider = ({ children, baseUrl, headers }) => {
+  const client = createMastraClient(baseUrl, headers);
+  return /* @__PURE__ */ jsx(MastraClientContext.Provider, { value: client, children });
+};
+const useMastraClient = () => useContext(MastraClientContext);
+const createMastraClient = (baseUrl, mastraClientHeaders = {}) => {
+  return new MastraClient({
+    baseUrl: baseUrl || "",
+    // only add the header if the baseUrl is not provided i.e it's a local dev environment
+    headers: !baseUrl ? { ...mastraClientHeaders, "x-mastra-dev-playground": "true" } : mastraClientHeaders
+  });
+};
+
+const MastraReactProvider = ({ children, baseUrl, headers }) => {
+  return /* @__PURE__ */ jsx(MastraClientProvider, { baseUrl, headers, children });
+};
+
+const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+  if (chunk.type === "workflow-start") {
+    return {
+      input: prev?.input,
+      status: "running",
+      steps: prev?.steps || {}
+    };
+  }
+  if (chunk.type === "workflow-canceled") {
+    return {
+      ...prev,
+      status: "canceled"
+    };
+  }
+  if (chunk.type === "workflow-finish") {
+    const finalStatus = chunk.payload.workflowStatus;
+    const prevSteps = prev?.steps ?? {};
+    const lastStep = Object.values(prevSteps).pop();
+    return {
+      ...prev,
+      status: chunk.payload.workflowStatus,
+      ...finalStatus === "success" && lastStep?.status === "success" ? { result: lastStep?.output } : finalStatus === "failed" && lastStep?.status === "failed" ? { error: lastStep?.error } : {}
+    };
+  }
+  const { stepCallId, stepName, ...newPayload } = chunk.payload ?? {};
+  const newSteps = {
+    ...prev?.steps,
+    [chunk.payload.id]: {
+      ...prev?.steps?.[chunk.payload.id],
+      ...newPayload
+    }
+  };
+  if (chunk.type === "workflow-step-start") {
+    return {
+      ...prev,
+      steps: newSteps
+    };
+  }
+  if (chunk.type === "workflow-step-suspended") {
+    const suspendedStepIds = Object.entries(newSteps).flatMap(
+      ([stepId, stepResult]) => {
+        if (stepResult?.status === "suspended") {
+          const nestedPath = stepResult?.suspendPayload?.__workflow_meta?.path;
+          return nestedPath ? [[stepId, ...nestedPath]] : [[stepId]];
+        }
+        return [];
+      }
+    );
+    return {
+      ...prev,
+      status: "suspended",
+      steps: newSteps,
+      suspendPayload: chunk.payload.suspendPayload,
+      suspended: suspendedStepIds
+    };
+  }
+  if (chunk.type === "workflow-step-waiting") {
+    return {
+      ...prev,
+      status: "waiting",
+      steps: newSteps
+    };
+  }
+  if (chunk.type === "workflow-step-result") {
+    return {
+      ...prev,
+      steps: newSteps
+    };
+  }
+  return prev;
+};
+const toUIMessage = ({ chunk, conversation, metadata }) => {
+  const result = [...conversation];
+  switch (chunk.type) {
+    case "tripwire": {
+      const newMessage = {
+        id: `tripwire-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: chunk.payload.tripwireReason
+          }
+        ],
+        metadata: {
+          ...metadata,
+          status: "warning"
+        }
+      };
+      return [...result, newMessage];
+    }
+    case "start": {
+      const newMessage = {
+        id: `start-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [],
+        metadata
+      };
+      return [...result, newMessage];
+    }
+    case "text-start":
+    case "text-delta": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      let textPartIndex = parts.findIndex((part) => part.type === "text");
+      if (chunk.type === "text-start") {
+        if (textPartIndex === -1) {
+          parts.push({
+            type: "text",
+            text: "",
+            state: "streaming",
+            providerMetadata: chunk.payload.providerMetadata
+          });
+        }
+      } else {
+        if (textPartIndex === -1) {
+          parts.push({
+            type: "text",
+            text: chunk.payload.text,
+            state: "streaming",
+            providerMetadata: chunk.payload.providerMetadata
+          });
+        } else {
+          const textPart = parts[textPartIndex];
+          if (textPart.type === "text") {
+            parts[textPartIndex] = {
+              ...textPart,
+              text: textPart.text + chunk.payload.text,
+              state: "streaming"
+            };
+          }
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "reasoning-delta": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        const newMessage = {
+          id: `reasoning-${chunk.runId + Date.now()}`,
+          role: "assistant",
+          parts: [
+            {
+              type: "reasoning",
+              text: chunk.payload.text,
+              state: "streaming",
+              providerMetadata: chunk.payload.providerMetadata
+            }
+          ],
+          metadata
+        };
+        return [...result, newMessage];
+      }
+      const parts = [...lastMessage.parts];
+      let reasoningPartIndex = parts.findIndex((part) => part.type === "reasoning");
+      if (reasoningPartIndex === -1) {
+        parts.push({
+          type: "reasoning",
+          text: chunk.payload.text,
+          state: "streaming",
+          providerMetadata: chunk.payload.providerMetadata
+        });
+      } else {
+        const reasoningPart = parts[reasoningPartIndex];
+        if (reasoningPart.type === "reasoning") {
+          parts[reasoningPartIndex] = {
+            ...reasoningPart,
+            text: reasoningPart.text + chunk.payload.text,
+            state: "streaming"
+          };
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "tool-call": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        const newMessage = {
+          id: `tool-call-${chunk.runId + Date.now()}`,
+          role: "assistant",
+          parts: [
+            {
+              type: "dynamic-tool",
+              toolName: chunk.payload.toolName,
+              toolCallId: chunk.payload.toolCallId,
+              state: "input-available",
+              input: chunk.payload.args,
+              callProviderMetadata: chunk.payload.providerMetadata
+            }
+          ],
+          metadata
+        };
+        return [...result, newMessage];
+      }
+      const parts = [...lastMessage.parts];
+      parts.push({
+        type: "dynamic-tool",
+        toolName: chunk.payload.toolName,
+        toolCallId: chunk.payload.toolCallId,
+        state: "input-available",
+        input: chunk.payload.args,
+        callProviderMetadata: chunk.payload.providerMetadata
+      });
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "tool-result": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex(
+        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+      );
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool") {
+          if (chunk.payload.isError) {
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName: toolPart.toolName,
+              toolCallId: toolPart.toolCallId,
+              state: "output-error",
+              input: toolPart.input,
+              errorText: String(chunk.payload.result),
+              callProviderMetadata: chunk.payload.providerMetadata
+            };
+          } else {
+            const isWorkflow = Boolean(chunk.payload.result?.result?.steps);
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName: toolPart.toolName,
+              toolCallId: toolPart.toolCallId,
+              state: "output-available",
+              input: toolPart.input,
+              output: isWorkflow ? chunk.payload.result?.result : chunk.payload.result,
+              callProviderMetadata: chunk.payload.providerMetadata
+            };
+          }
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "tool-output": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex(
+        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+      );
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool") {
+          if (chunk.payload.output?.type?.startsWith("workflow-")) {
+            const existingWorkflowState = toolPart.output || {};
+            const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(
+              existingWorkflowState,
+              chunk.payload.output
+            );
+            parts[toolPartIndex] = {
+              ...toolPart,
+              output: updatedWorkflowState
+            };
+          } else {
+            const currentOutput = toolPart.output || [];
+            const existingOutput = Array.isArray(currentOutput) ? currentOutput : [];
+            parts[toolPartIndex] = {
+              ...toolPart,
+              output: [...existingOutput, chunk.payload.output]
+            };
+          }
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "source": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      if (chunk.payload.sourceType === "url") {
+        parts.push({
+          type: "source-url",
+          sourceId: chunk.payload.id,
+          url: chunk.payload.url || "",
+          title: chunk.payload.title,
+          providerMetadata: chunk.payload.providerMetadata
+        });
+      } else if (chunk.payload.sourceType === "document") {
+        parts.push({
+          type: "source-document",
+          sourceId: chunk.payload.id,
+          mediaType: chunk.payload.mimeType || "application/octet-stream",
+          title: chunk.payload.title,
+          filename: chunk.payload.filename,
+          providerMetadata: chunk.payload.providerMetadata
+        });
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "file": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      let url;
+      if (typeof chunk.payload.data === "string") {
+        url = chunk.payload.base64 ? `data:${chunk.payload.mimeType};base64,${chunk.payload.data}` : `data:${chunk.payload.mimeType},${encodeURIComponent(chunk.payload.data)}`;
+      } else {
+        const base64 = btoa(String.fromCharCode(...chunk.payload.data));
+        url = `data:${chunk.payload.mimeType};base64,${base64}`;
+      }
+      parts.push({
+        type: "file",
+        mediaType: chunk.payload.mimeType,
+        url,
+        providerMetadata: chunk.payload.providerMetadata
+      });
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "finish": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = lastMessage.parts.map((part) => {
+        if (part.type === "text" && part.state === "streaming") {
+          return { ...part, state: "done" };
+        }
+        if (part.type === "reasoning" && part.state === "streaming") {
+          return { ...part, state: "done" };
+        }
+        return part;
+      });
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "error": {
+      const newMessage = {
+        id: `error-${chunk.runId + Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: chunk.payload.error
+          }
+        ],
+        metadata: {
+          ...metadata,
+          status: "error"
+        }
+      };
+      return [...result, newMessage];
+    }
+    // For all other chunk types, return conversation unchanged
+    default:
+      return result;
+  }
+};
+
+const toAssistantUIMessage = (message) => {
+  const extendedMessage = message;
+  const content = message.parts.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        text: part.text,
+        metadata: message.metadata
+      };
+    }
+    if (part.type === "reasoning") {
+      return {
+        type: "reasoning",
+        text: part.text,
+        metadata: message.metadata
+      };
+    }
+    if (part.type === "source-url") {
+      return {
+        type: "source",
+        sourceType: "url",
+        id: part.sourceId,
+        url: part.url,
+        title: part.title,
+        metadata: message.metadata
+      };
+    }
+    if (part.type === "source-document") {
+      return {
+        type: "file",
+        filename: part.filename,
+        mimeType: part.mediaType,
+        data: "",
+        // Source documents don't have inline data
+        metadata: message.metadata
+      };
+    }
+    if (part.type === "file") {
+      return {
+        type: "file",
+        mimeType: part.mediaType,
+        data: part.url,
+        // Use URL as data source
+        metadata: message.metadata
+      };
+    }
+    if (part.type === "dynamic-tool") {
+      const baseToolCall = {
+        type: "tool-call",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        argsText: JSON.stringify(part.input),
+        args: part.input,
+        metadata: message.metadata
+      };
+      if (part.state === "output-error" && "errorText" in part) {
+        return { ...baseToolCall, result: part.errorText, isError: true };
+      }
+      if ("output" in part) {
+        return { ...baseToolCall, result: part.output };
+      }
+      return baseToolCall;
+    }
+    if (part.type.startsWith("tool-") && part.state !== "input-available") {
+      const toolName = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.substring(5);
+      const baseToolCall = {
+        type: "tool-call",
+        toolCallId: "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "",
+        toolName,
+        argsText: "input" in part ? JSON.stringify(part.input) : "{}",
+        args: "input" in part ? part.input : {},
+        metadata: message.metadata
+      };
+      if ("output" in part) {
+        return { ...baseToolCall, result: part.output };
+      } else if ("error" in part) {
+        return { ...baseToolCall, result: part.error, isError: true };
+      }
+      return baseToolCall;
+    }
+    return {
+      type: "text",
+      text: "",
+      metadata: message.metadata
+    };
+  });
+  let status;
+  if (message.role === "assistant" && content.length > 0) {
+    const hasStreamingParts = message.parts.some(
+      (part) => part.type === "text" && "state" in part && part.state === "streaming" || part.type === "reasoning" && "state" in part && part.state === "streaming"
+    );
+    const hasToolCalls = message.parts.some((part) => part.type === "dynamic-tool" || part.type.startsWith("tool-"));
+    const hasInputAvailableTools = message.parts.some(
+      (part) => part.type === "dynamic-tool" && part.state === "input-available"
+    );
+    const hasErrorTools = message.parts.some(
+      (part) => part.type === "dynamic-tool" && part.state === "output-error" || part.type.startsWith("tool-") && "error" in part
+    );
+    if (hasStreamingParts) {
+      status = { type: "running" };
+    } else if (hasInputAvailableTools && hasToolCalls) {
+      status = { type: "requires-action", reason: "tool-calls" };
+    } else if (hasErrorTools) {
+      status = { type: "incomplete", reason: "error" };
+    } else {
+      status = { type: "complete", reason: "stop" };
+    }
+  }
+  const threadMessage = {
+    role: message.role,
+    content,
+    id: message.id,
+    createdAt: extendedMessage.createdAt,
+    status,
+    attachments: extendedMessage.experimental_attachments
+  };
+  return threadMessage;
+};
+
+class AISdkNetworkTransformer {
+  transform({ chunk, conversation, metadata }) {
+    const newConversation = [...conversation];
+    if (chunk.type.startsWith("agent-execution-")) {
+      return this.handleAgentConversation(chunk, newConversation, metadata);
+    }
+    if (chunk.type.startsWith("workflow-execution-")) {
+      return this.handleWorkflowConversation(chunk, newConversation, metadata);
+    }
+    if (chunk.type.startsWith("tool-execution-")) {
+      return this.handleToolConversation(chunk, newConversation, metadata);
+    }
+    if (chunk.type === "network-execution-event-step-finish") {
+      const newMessage = {
+        id: `network-execution-event-step-finish-${chunk.runId}-${Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "text",
+            text: chunk.payload?.result || "",
+            state: "done"
+          }
+        ],
+        metadata
+      };
+      return [...newConversation, newMessage];
+    }
+    return newConversation;
+  }
+  handleAgentConversation = (chunk, newConversation, metadata) => {
+    if (chunk.type === "agent-execution-start") {
+      const primitiveId = chunk.payload?.args?.primitiveId;
+      const runId = chunk.payload.runId;
+      if (!primitiveId || !runId) return newConversation;
+      const newMessage = {
+        id: `agent-execution-start-${runId}-${Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: primitiveId,
+            toolCallId: runId,
+            state: "input-available",
+            input: chunk.payload.args
+          }
+        ],
+        metadata: {
+          ...metadata,
+          selectionReason: chunk.payload?.args?.selectionReason || "",
+          agentInput: chunk.payload?.args?.task,
+          mode: "network",
+          from: "AGENT"
+        }
+      };
+      return [...newConversation, newMessage];
+    }
+    if (chunk.type === "agent-execution-end") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool") {
+          const currentOutput = toolPart.output;
+          parts[toolPartIndex] = {
+            type: "dynamic-tool",
+            toolName: toolPart.toolName,
+            toolCallId: toolPart.toolCallId,
+            state: "output-available",
+            input: toolPart.input,
+            output: {
+              ...currentOutput,
+              result: currentOutput?.result || chunk.payload?.result || ""
+            }
+          };
+        }
+      }
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    if (chunk.type.startsWith("agent-execution-event-")) {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const agentChunk = chunk.payload;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
+      if (toolPartIndex === -1) return newConversation;
+      const toolPart = parts[toolPartIndex];
+      if (agentChunk.type === "text-delta") {
+        const childMessages = toolPart?.output?.childMessages || [];
+        const lastChildMessage = childMessages[childMessages.length - 1];
+        const textMessage = { type: "text", content: (lastChildMessage?.content || "") + agentChunk.payload.text };
+        const nextMessages = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+        parts[toolPartIndex] = {
+          ...toolPart,
+          output: {
+            childMessages: nextMessages
+          }
+        };
+      } else if (agentChunk.type === "tool-call") {
+        const childMessages = toolPart?.output?.childMessages || [];
+        parts[toolPartIndex] = {
+          ...toolPart,
+          output: {
+            ...toolPart?.output,
+            childMessages: [
+              ...childMessages,
+              {
+                type: "tool",
+                toolCallId: agentChunk.payload.toolCallId,
+                toolName: agentChunk.payload.toolName,
+                args: agentChunk.payload.args
+              }
+            ]
+          }
+        };
+      } else if (agentChunk.type === "tool-output") {
+        if (agentChunk.payload?.output?.type?.startsWith("workflow-")) {
+          const childMessages = toolPart?.output?.childMessages || [];
+          const lastToolIndex = childMessages.length - 1;
+          const currentMessage = childMessages[lastToolIndex];
+          const actualExistingWorkflowState = currentMessage?.toolOutput || {};
+          const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(
+            actualExistingWorkflowState,
+            agentChunk.payload.output
+          );
+          if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+            parts[toolPartIndex] = {
+              ...toolPart,
+              output: {
+                ...toolPart?.output,
+                childMessages: [
+                  ...childMessages.slice(0, -1),
+                  {
+                    ...currentMessage,
+                    toolOutput: updatedWorkflowState
+                  }
+                ]
+              }
+            };
+          }
+        }
+      } else if (agentChunk.type === "tool-result") {
+        const childMessages = toolPart?.output?.childMessages || [];
+        const lastToolIndex = childMessages.length - 1;
+        const isWorkflow = Boolean(agentChunk.payload?.result?.result?.steps);
+        if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+          parts[toolPartIndex] = {
+            ...toolPart,
+            output: {
+              ...toolPart?.output,
+              childMessages: [
+                ...childMessages.slice(0, -1),
+                {
+                  ...childMessages[lastToolIndex],
+                  toolOutput: isWorkflow ? agentChunk.payload.result.result : agentChunk.payload.result
+                }
+              ]
+            }
+          };
+        }
+      }
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    return newConversation;
+  };
+  handleWorkflowConversation = (chunk, newConversation, metadata) => {
+    if (chunk.type === "workflow-execution-start") {
+      const primitiveId = chunk.payload?.args?.primitiveId;
+      const runId = chunk.payload.runId;
+      if (!primitiveId || !runId) return newConversation;
+      let agentInput;
+      try {
+        agentInput = JSON.parse(chunk?.payload?.args?.prompt);
+      } catch (e) {
+        agentInput = chunk?.payload?.args?.prompt;
+      }
+      const newMessage = {
+        id: `workflow-start-${runId}-${Date.now()}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: primitiveId,
+            toolCallId: runId,
+            state: "input-available",
+            input: chunk.payload.args
+          }
+        ],
+        metadata: {
+          ...metadata,
+          selectionReason: chunk.payload?.args?.selectionReason || "",
+          from: "WORKFLOW",
+          mode: "network",
+          agentInput
+        }
+      };
+      return [...newConversation, newMessage];
+    }
+    if (chunk.type.startsWith("workflow-execution-event-")) {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex((part) => part.type === "dynamic-tool");
+      if (toolPartIndex === -1) return newConversation;
+      const toolPart = parts[toolPartIndex];
+      if (toolPart.type !== "dynamic-tool") return newConversation;
+      const existingWorkflowState = toolPart.output || {};
+      const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload);
+      parts[toolPartIndex] = {
+        ...toolPart,
+        output: updatedWorkflowState
+      };
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    return newConversation;
+  };
+  handleToolConversation = (chunk, newConversation, metadata) => {
+    if (chunk.type === "tool-execution-start") {
+      const { args: argsData } = chunk.payload;
+      const lastMessage = newConversation[newConversation.length - 1];
+      const nestedArgs = argsData.args || {};
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        const newMessage = {
+          id: `tool-start-${chunk.runId}-${Date.now()}`,
+          role: "assistant",
+          parts: [
+            {
+              type: "dynamic-tool",
+              toolName: argsData.toolName || "unknown",
+              toolCallId: argsData.toolCallId || "unknown",
+              state: "input-available",
+              input: nestedArgs
+            }
+          ],
+          metadata: {
+            ...metadata,
+            selectionReason: metadata?.mode === "network" ? metadata.selectionReason || argsData.selectionReason : "",
+            mode: "network",
+            agentInput: nestedArgs
+          }
+        };
+        return [...newConversation, newMessage];
+      }
+      const parts = [...lastMessage.parts];
+      parts.push({
+        type: "dynamic-tool",
+        toolName: argsData.toolName || "unknown",
+        toolCallId: argsData.toolCallId || "unknown",
+        state: "input-available",
+        input: nestedArgs
+      });
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    if (chunk.type === "tool-execution-end") {
+      const lastMessage = newConversation[newConversation.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex(
+        (part) => part.type === "dynamic-tool" && "toolCallId" in part && part.toolCallId === chunk.payload.toolCallId
+      );
+      if (toolPartIndex !== -1) {
+        const toolPart = parts[toolPartIndex];
+        if (toolPart.type === "dynamic-tool") {
+          const currentOutput = toolPart.output;
+          parts[toolPartIndex] = {
+            type: "dynamic-tool",
+            toolName: toolPart.toolName,
+            toolCallId: toolPart.toolCallId,
+            state: "output-available",
+            input: toolPart.input,
+            output: currentOutput?.result || chunk.payload?.result || ""
+          };
+        }
+      }
+      return [
+        ...newConversation.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    return newConversation;
+  };
+}
+
+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 useChat = ({ agentId, initializeMessages }) => {
+  const [messages, setMessages] = useState(
+    () => resolveInitialMessages(initializeMessages?.() || [])
+  );
+  const baseClient = useMastraClient();
+  const [isRunning, setIsRunning] = useState(false);
+  const generate = async ({
+    coreUserMessages,
+    runtimeContext,
+    threadId,
+    modelSettings,
+    signal,
+    onFinish
+  }) => {
+    const {
+      frequencyPenalty,
+      presencePenalty,
+      maxRetries,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      instructions,
+      providerOptions,
+      maxSteps
+    } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const response = await agent.generate({
+      messages: coreUserMessages,
+      runId: agentId,
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      runtimeContext,
+      ...threadId ? { threadId, resourceId: agentId } : {},
+      providerOptions
+    });
+    setIsRunning(false);
+    if (response && "uiMessages" in response.response && response.response.uiMessages) {
+      onFinish?.(response.response.uiMessages);
+      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
+        ...message,
+        metadata: {
+          mode: "generate"
+        }
+      }));
+      setMessages((prev) => [...prev, ...mastraUIMessages]);
+    }
+  };
+  const stream = async ({ coreUserMessages, runtimeContext, threadId, onChunk, modelSettings, signal }) => {
+    const {
+      frequencyPenalty,
+      presencePenalty,
+      maxRetries,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      instructions,
+      providerOptions,
+      maxSteps
+    } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const response = await agent.stream({
+      messages: coreUserMessages,
+      runId: agentId,
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      runtimeContext,
+      ...threadId ? { threadId, resourceId: agentId } : {},
+      providerOptions
+    });
+    if (!response.body) {
+      setIsRunning(false);
+      throw new Error("[Stream] No response body");
+    }
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        flushSync(() => {
+          setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
+        });
+        onChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  const network = async ({
+    coreUserMessages,
+    runtimeContext,
+    threadId,
+    onNetworkChunk,
+    modelSettings,
+    signal
+  }) => {
+    const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const response = await agent.network({
+      messages: coreUserMessages,
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      runId: agentId,
+      runtimeContext,
+      ...threadId ? { thread: threadId, resourceId: agentId } : {}
+    });
+    const transformer = new AISdkNetworkTransformer();
+    await response.processDataStream({
+      onChunk: async (chunk) => {
+        flushSync(() => {
+          setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        });
+        onNetworkChunk?.(chunk);
+      }
+    });
+    setIsRunning(false);
+  };
+  return {
+    network,
+    stream,
+    generate,
+    isRunning,
+    messages,
+    setMessages,
+    cancelRun: () => setIsRunning(false)
+  };
+};
+
+export { MastraReactProvider, mapWorkflowStreamChunkToWatchResult, toAssistantUIMessage, toUIMessage, useChat, useMastraClient };
+//# sourceMappingURL=index.es.js.map