@mastra/react 0.0.2-alpha.1

package/dist/index.es.js

@@ -0,0 +1,856 @@
+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 useChat = ({ agentId, initializeMessages }) => {
+  const [messages, setMessages] = useState(initializeMessages || []);
+  const baseClient = useMastraClient();
+  const [isRunning, setIsRunning] = useState(false);
+  const streamVNext = async ({
+    coreUserMessages,
+    runtimeContext,
+    threadId,
+    onChunk,
+    modelSettings,
+    signal
+  }) => {
+    const {
+      frequencyPenalty,
+      presencePenalty,
+      maxRetries,
+      maxTokens,
+      temperature,
+      topK,
+      topP,
+      instructions,
+      providerOptions
+    } = modelSettings || {};
+    setIsRunning(true);
+    const clientWithAbort = new MastraClient({
+      ...baseClient.options,
+      abortSignal: signal
+    });
+    const agent = clientWithAbort.getAgent(agentId);
+    const response = await agent.streamVNext({
+      messages: coreUserMessages,
+      runId: agentId,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      runtimeContext,
+      ...threadId ? { threadId, resourceId: agentId } : {},
+      providerOptions
+    });
+    if (!response.body) {
+      setIsRunning(false);
+      throw new Error("[StreamVNext] No response body");
+    }
+    await response.processDataStream({
+      onChunk: (chunk) => {
+        flushSync(() => {
+          setMessages((prev) => onChunk(chunk, prev));
+        });
+        return Promise.resolve();
+      }
+    });
+    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 } : {}
+    });
+    await response.processDataStream({
+      onChunk: (chunk) => {
+        flushSync(() => {
+          setMessages((prev) => onNetworkChunk(chunk, prev));
+        });
+        return Promise.resolve();
+      }
+    });
+    setIsRunning(false);
+  };
+  return {
+    network,
+    streamVNext,
+    isRunning,
+    messages,
+    setMessages,
+    cancelRun: () => setIsRunning(false)
+  };
+};
+
+const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
+  if (chunk.type === "workflow-start") {
+    return {
+      ...prev,
+      runId: chunk.runId,
+      eventTimestamp: /* @__PURE__ */ new Date(),
+      payload: {
+        ...prev?.payload || {},
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status: "running",
+          steps: {}
+        }
+      }
+    };
+  }
+  if (chunk.type === "workflow-step-start") {
+    const current = prev?.payload?.workflowState?.steps?.[chunk.payload.id] || {};
+    return {
+      ...prev,
+      payload: {
+        ...prev.payload,
+        currentStep: {
+          id: chunk.payload.id,
+          ...chunk.payload
+        },
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          steps: {
+            ...prev?.payload?.workflowState?.steps,
+            [chunk.payload.id]: {
+              ...current || {},
+              ...chunk.payload
+            }
+          }
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  if (chunk.type === "workflow-step-suspended") {
+    const current = prev?.payload?.workflowState?.steps?.[chunk.payload.id] || {};
+    return {
+      ...prev,
+      payload: {
+        ...prev?.payload,
+        currentStep: {
+          id: chunk.payload.id,
+          ...prev?.payload?.currentStep,
+          ...chunk.payload
+        },
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status: "suspended",
+          steps: {
+            ...prev?.payload?.workflowState?.steps,
+            [chunk.payload.id]: {
+              ...current || {},
+              ...chunk.payload
+            }
+          }
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  if (chunk.type === "workflow-step-waiting") {
+    const current = prev?.payload?.workflowState?.steps?.[chunk.payload.id] || {};
+    return {
+      ...prev,
+      payload: {
+        ...prev?.payload,
+        currentStep: {
+          id: chunk.payload.id,
+          ...prev?.payload?.currentStep || {},
+          ...chunk.payload
+        },
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status: "waiting",
+          steps: {
+            ...prev?.payload?.workflowState?.steps,
+            [chunk.payload.id]: {
+              ...current,
+              ...chunk.payload
+            }
+          }
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  if (chunk.type === "workflow-step-result") {
+    const status = chunk.payload.status;
+    const current = prev?.payload?.workflowState?.steps?.[chunk.payload.id] || {};
+    const next = {
+      ...prev,
+      payload: {
+        ...prev?.payload,
+        currentStep: {
+          id: chunk.payload.id,
+          ...prev?.payload?.currentStep || {},
+          ...chunk.payload
+        },
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status,
+          steps: {
+            ...prev?.payload?.workflowState?.steps,
+            [chunk.payload.id]: {
+              ...current,
+              ...chunk.payload
+            }
+          }
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+    return next;
+  }
+  if (chunk.type === "workflow-canceled") {
+    return {
+      ...prev,
+      payload: {
+        ...prev?.payload,
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status: "canceled"
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  if (chunk.type === "workflow-finish") {
+    return {
+      ...prev,
+      payload: {
+        ...prev?.payload,
+        currentStep: void 0,
+        workflowState: {
+          ...prev?.payload?.workflowState,
+          status: chunk.payload.workflowStatus
+        }
+      },
+      eventTimestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  return prev;
+};
+const toUIMessage = ({
+  chunk,
+  conversation
+}) => {
+  const result = [...conversation];
+  switch (chunk.type) {
+    case "start": {
+      const newMessage = {
+        id: chunk.runId,
+        role: "assistant",
+        parts: []
+      };
+      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: chunk.runId,
+          role: "assistant",
+          parts: [
+            {
+              type: "reasoning",
+              text: chunk.payload.text,
+              state: "streaming",
+              providerMetadata: chunk.payload.providerMetadata
+            }
+          ]
+        };
+        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: chunk.runId,
+          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
+            }
+          ]
+        };
+        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 {
+            parts[toolPartIndex] = {
+              type: "dynamic-tool",
+              toolName: toolPart.toolName,
+              toolCallId: toolPart.toolCallId,
+              state: "output-available",
+              input: toolPart.input,
+              output: toolPart.output,
+              callProviderMetadata: chunk.payload.providerMetadata
+            };
+          }
+        }
+      }
+      return [
+        ...result.slice(0, -1),
+        {
+          ...lastMessage,
+          parts
+        }
+      ];
+    }
+    case "tool-output": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.parts];
+      const toolPartIndex = parts.findIndex(
+        (part) => part.type === "dynamic-tool" && "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 currentOutput = toolPart.output || {};
+            const existingWorkflowState = currentOutput || {};
+            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": {
+      return result;
+    }
+    // For all other chunk types, return conversation unchanged
+    default:
+      return result;
+  }
+};
+
+const toNetworkUIMessage = ({
+  chunk,
+  conversation
+}) => {
+  const result = [...conversation];
+  if (chunk.type === "agent-execution-start" || chunk.type === "workflow-execution-start") {
+    const primitiveId = chunk.payload?.args?.primitiveId;
+    const runId = chunk.payload.runId;
+    if (!primitiveId || !runId) return result;
+    const newMessage = {
+      id: runId,
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          toolName: primitiveId,
+          toolCallId: runId,
+          state: "input-available",
+          input: chunk.payload.args,
+          output: {
+            networkMetadata: {
+              selectionReason: chunk.payload?.args?.selectionReason || "",
+              from: chunk.type === "agent-execution-start" ? "AGENT" : "WORKFLOW"
+            },
+            result: void 0
+          }
+        }
+      ]
+    };
+    return [...result, newMessage];
+  }
+  if (chunk.type.startsWith("agent-execution-event-")) {
+    const agentChunk = chunk.payload;
+    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");
+    if (toolPartIndex === -1) return result;
+    const toolPart = parts[toolPartIndex];
+    if (toolPart.type !== "dynamic-tool") return result;
+    if (agentChunk.type === "text-delta") {
+      const currentInput = toolPart.input;
+      const messages = currentInput?.messages || [];
+      const lastMessage2 = messages[messages.length - 1];
+      const nextMessages = lastMessage2?.type === "text" ? [
+        ...messages.slice(0, -1),
+        { type: "text", content: (lastMessage2?.content || "") + agentChunk.payload.text }
+      ] : [...messages, { type: "text", content: agentChunk.payload.text }];
+      parts[toolPartIndex] = {
+        ...toolPart,
+        input: {
+          ...currentInput,
+          messages: nextMessages
+        }
+      };
+    } else if (agentChunk.type === "tool-call") {
+      const currentInput = toolPart.input;
+      const messages = currentInput?.messages || [];
+      parts[toolPartIndex] = {
+        ...toolPart,
+        input: {
+          ...currentInput,
+          messages: [
+            ...messages,
+            {
+              type: "tool",
+              toolCallId: agentChunk.payload.toolCallId,
+              toolName: agentChunk.payload.toolName,
+              toolInput: agentChunk.payload.args
+            }
+          ]
+        }
+      };
+    } else if (agentChunk.type === "tool-result") {
+      const currentInput = toolPart.input;
+      const messages = currentInput?.messages || [];
+      const lastToolIndex = messages.length - 1;
+      if (lastToolIndex >= 0 && messages[lastToolIndex]?.type === "tool") {
+        parts[toolPartIndex] = {
+          ...toolPart,
+          input: {
+            ...currentInput,
+            messages: [
+              ...messages.slice(0, -1),
+              {
+                ...messages[lastToolIndex],
+                toolOutput: agentChunk.payload.result
+              }
+            ]
+          }
+        };
+      }
+    } else if (agentChunk.type === "tool-output") {
+      if (agentChunk.payload?.output?.type?.startsWith("workflow-")) {
+        const currentOutput = toolPart.output || {};
+        const existingWorkflowState = currentOutput.result || {};
+        const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(
+          existingWorkflowState,
+          agentChunk.payload.output
+        );
+        parts[toolPartIndex] = {
+          ...toolPart,
+          output: {
+            networkMetadata: currentOutput.networkMetadata,
+            result: updatedWorkflowState
+          }
+        };
+      }
+    }
+    return [
+      ...result.slice(0, -1),
+      {
+        ...lastMessage,
+        parts
+      }
+    ];
+  }
+  if (chunk.type.startsWith("workflow-execution-event-")) {
+    const workflowChunk = chunk.payload;
+    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");
+    if (toolPartIndex === -1) return result;
+    const toolPart = parts[toolPartIndex];
+    if (toolPart.type !== "dynamic-tool") return result;
+    const currentOutput = toolPart.output || {};
+    const existingWorkflowState = currentOutput.result || {};
+    const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, workflowChunk);
+    parts[toolPartIndex] = {
+      ...toolPart,
+      output: {
+        networkMetadata: currentOutput.networkMetadata,
+        result: updatedWorkflowState
+      }
+    };
+    return [
+      ...result.slice(0, -1),
+      {
+        ...lastMessage,
+        parts
+      }
+    ];
+  }
+  if (chunk.type === "tool-execution-start") {
+    const { args: argsData } = chunk.payload;
+    const lastMessage = result[result.length - 1];
+    const nestedArgs = argsData.args || {};
+    if (!lastMessage || lastMessage.role !== "assistant") {
+      const newMessage = {
+        id: chunk.runId,
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: argsData.toolName || "unknown",
+            toolCallId: argsData.toolCallId || "unknown",
+            state: "input-available",
+            input: nestedArgs,
+            output: {
+              networkMetadata: {
+                selectionReason: argsData.selectionReason || ""
+              },
+              result: void 0
+            }
+          }
+        ]
+      };
+      return [...result, newMessage];
+    }
+    const parts = [...lastMessage.parts];
+    parts.push({
+      type: "dynamic-tool",
+      toolName: argsData.toolName || "unknown",
+      toolCallId: argsData.toolCallId || "unknown",
+      state: "input-available",
+      input: nestedArgs,
+      output: {
+        networkMetadata: {
+          selectionReason: argsData.selectionReason || ""
+        },
+        result: void 0
+      }
+    });
+    return [
+      ...result.slice(0, -1),
+      {
+        ...lastMessage,
+        parts
+      }
+    ];
+  }
+  if (chunk.type === "tool-execution-end") {
+    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") {
+        const currentOutput = toolPart.output;
+        parts[toolPartIndex] = {
+          type: "dynamic-tool",
+          toolName: toolPart.toolName,
+          toolCallId: toolPart.toolCallId,
+          state: "output-available",
+          input: toolPart.input,
+          output: {
+            networkMetadata: currentOutput?.networkMetadata,
+            result: chunk.payload.result
+          }
+        };
+      }
+    }
+    return [
+      ...result.slice(0, -1),
+      {
+        ...lastMessage,
+        parts
+      }
+    ];
+  }
+  if (chunk.type === "agent-execution-end" || chunk.type === "workflow-execution-end") {
+    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");
+    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: {
+            networkMetadata: currentOutput?.networkMetadata,
+            result: currentOutput?.result || chunk.payload?.result || ""
+          }
+        };
+      }
+    }
+    return [
+      ...result.slice(0, -1),
+      {
+        ...lastMessage,
+        parts
+      }
+    ];
+  }
+  if (chunk.type === "network-execution-event-step-finish") {
+    const newMessage = {
+      id: chunk.runId,
+      role: "assistant",
+      parts: [
+        {
+          type: "text",
+          text: chunk.payload?.result || "",
+          state: "done"
+        }
+      ]
+    };
+    return [...result, newMessage];
+  }
+  return result;
+};
+
+export { MastraReactProvider, mapWorkflowStreamChunkToWatchResult, toNetworkUIMessage, toUIMessage, useChat, useMastraClient };
+//# sourceMappingURL=index.es.js.map