@mastra/react 0.0.0-fix-runtimeContext-passing-chatRoute-20251008220150 → 0.0.0-unified-sidebar-20251010130811

package/dist/index.cjs.js

@@ -25,165 +25,6 @@ const MastraReactProvider = ({ children, baseUrl, headers }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(MastraClientProvider, { baseUrl, headers, children });
 };
 
-const useChat = ({ agentId, initializeMessages }) => {
-  const [messages, setMessages] = react.useState(initializeMessages || []);
-  const baseClient = useMastraClient();
-  const [isRunning, setIsRunning] = react.useState(false);
-  const generate = async ({
-    coreUserMessages,
-    runtimeContext,
-    threadId,
-    modelSettings,
-    signal,
-    onFinish
-  }) => {
-    const {
-      frequencyPenalty,
-      presencePenalty,
-      maxRetries,
-      maxTokens,
-      temperature,
-      topK,
-      topP,
-      instructions,
-      providerOptions
-    } = modelSettings || {};
-    setIsRunning(true);
-    const clientWithAbort = new clientJs.MastraClient({
-      ...baseClient.options,
-      abortSignal: signal
-    });
-    const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.generate({
-      messages: coreUserMessages,
-      runId: agentId,
-      modelSettings: {
-        frequencyPenalty,
-        presencePenalty,
-        maxRetries,
-        maxOutputTokens: maxTokens,
-        temperature,
-        topK,
-        topP
-      },
-      instructions,
-      runtimeContext,
-      ...threadId ? { threadId, resourceId: agentId } : {},
-      providerOptions
-    });
-    setIsRunning(false);
-    const uiMessages = response && "uiMessages" in response.response && response.response.uiMessages ? response.response.uiMessages : [];
-    const formatted = onFinish({ messages: uiMessages, tripwireReason: response.tripwireReason });
-    setMessages((prev) => [...prev, ...formatted]);
-  };
-  const stream = async ({
-    coreUserMessages,
-    runtimeContext,
-    threadId,
-    onChunk,
-    modelSettings,
-    signal
-  }) => {
-    const {
-      frequencyPenalty,
-      presencePenalty,
-      maxRetries,
-      maxTokens,
-      temperature,
-      topK,
-      topP,
-      instructions,
-      providerOptions
-    } = modelSettings || {};
-    setIsRunning(true);
-    const clientWithAbort = new clientJs.MastraClient({
-      ...baseClient.options,
-      abortSignal: signal
-    });
-    const agent = clientWithAbort.getAgent(agentId);
-    const response = await agent.stream({
-      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("[Stream] No response body");
-    }
-    await response.processDataStream({
-      onChunk: (chunk) => {
-        reactDom.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 clientJs.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) => {
-        reactDom.flushSync(() => {
-          setMessages((prev) => onNetworkChunk(chunk, prev));
-        });
-        return Promise.resolve();
-      }
-    });
-    setIsRunning(false);
-  };
-  return {
-    network,
-    stream,
-    generate,
-    isRunning,
-    messages,
-    setMessages,
-    cancelRun: () => setIsRunning(false)
-  };
-};
-
 const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
   if (chunk.type === "workflow-start") {
     return {
@@ -255,17 +96,32 @@ const mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
   }
   return prev;
 };
-const toUIMessage = ({
-  chunk,
-  conversation
-}) => {
+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: chunk.runId,
+        id: `start-${chunk.runId + Date.now()}`,
         role: "assistant",
-        parts: []
+        parts: [],
+        metadata
       };
       return [...result, newMessage];
     }
@@ -315,7 +171,7 @@ const toUIMessage = ({
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") {
         const newMessage = {
-          id: chunk.runId,
+          id: `reasoning-${chunk.runId + Date.now()}`,
           role: "assistant",
           parts: [
             {
@@ -324,7 +180,8 @@ const toUIMessage = ({
               state: "streaming",
               providerMetadata: chunk.payload.providerMetadata
             }
-          ]
+          ],
+          metadata
         };
         return [...result, newMessage];
       }
@@ -359,7 +216,7 @@ const toUIMessage = ({
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") {
         const newMessage = {
-          id: chunk.runId,
+          id: `tool-call-${chunk.runId + Date.now()}`,
           role: "assistant",
           parts: [
             {
@@ -370,7 +227,8 @@ const toUIMessage = ({
               input: chunk.payload.args,
               callProviderMetadata: chunk.payload.providerMetadata
             }
-          ]
+          ],
+          metadata
         };
         return [...result, newMessage];
       }
@@ -412,13 +270,14 @@ const toUIMessage = ({
               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: toolPart.output,
+              output: isWorkflow ? chunk.payload.result?.result : chunk.payload.result,
               callProviderMetadata: chunk.payload.providerMetadata
             };
           }
@@ -546,283 +405,26 @@ const toUIMessage = ({
       ];
     }
     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,
+        id: `error-${chunk.runId + Date.now()}`,
         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
-            }
+            type: "text",
+            text: chunk.payload.error
           }
-        ]
+        ],
+        metadata: {
+          ...metadata,
+          status: "error"
+        }
       };
       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];
+    // For all other chunk types, return conversation unchanged
+    default:
+      return result;
   }
-  return result;
 };
 
 const toAssistantUIMessage = (message) => {
@@ -831,13 +433,15 @@ const toAssistantUIMessage = (message) => {
     if (part.type === "text") {
       return {
         type: "text",
-        text: part.text
+        text: part.text,
+        metadata: message.metadata
       };
     }
     if (part.type === "reasoning") {
       return {
         type: "reasoning",
-        text: part.text
+        text: part.text,
+        metadata: message.metadata
       };
     }
     if (part.type === "source-url") {
@@ -846,7 +450,8 @@ const toAssistantUIMessage = (message) => {
         sourceType: "url",
         id: part.sourceId,
         url: part.url,
-        title: part.title
+        title: part.title,
+        metadata: message.metadata
       };
     }
     if (part.type === "source-document") {
@@ -854,16 +459,18 @@ const toAssistantUIMessage = (message) => {
         type: "file",
         filename: part.filename,
         mimeType: part.mediaType,
-        data: ""
+        data: "",
         // Source documents don't have inline data
+        metadata: message.metadata
       };
     }
     if (part.type === "file") {
       return {
         type: "file",
         mimeType: part.mediaType,
-        data: part.url
+        data: part.url,
         // Use URL as data source
+        metadata: message.metadata
       };
     }
     if (part.type === "dynamic-tool") {
@@ -871,22 +478,27 @@ const toAssistantUIMessage = (message) => {
         type: "tool-call",
         toolCallId: part.toolCallId,
         toolName: part.toolName,
-        argsText: JSON.stringify(part.input)
+        argsText: JSON.stringify(part.input),
+        args: part.input,
+        metadata: message.metadata
       };
-      if (part.state === "output-available" && "output" in part) {
-        return { ...baseToolCall, result: part.output };
-      } else if (part.state === "output-error" && "errorText" in part) {
+      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-")) {
+    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) : "{}"
+        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 };
@@ -897,7 +509,8 @@ const toAssistantUIMessage = (message) => {
     }
     return {
       type: "text",
-      text: ""
+      text: "",
+      metadata: message.metadata
     };
   });
   let status;
@@ -922,25 +535,574 @@ const toAssistantUIMessage = (message) => {
       status = { type: "complete", reason: "stop" };
     }
   }
-  const metadata = extendedMessage.metadata ? {
-    custom: extendedMessage.metadata
-  } : void 0;
   const threadMessage = {
     role: message.role,
     content,
     id: message.id,
     createdAt: extendedMessage.createdAt,
     status,
-    metadata,
     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] = react.useState(
+    () => resolveInitialMessages(initializeMessages?.() || [])
+  );
+  const baseClient = useMastraClient();
+  const [isRunning, setIsRunning] = react.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 clientJs.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 clientJs.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) => {
+        reactDom.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 clientJs.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) => {
+        reactDom.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)
+  };
+};
+
 exports.MastraReactProvider = MastraReactProvider;
 exports.mapWorkflowStreamChunkToWatchResult = mapWorkflowStreamChunkToWatchResult;
 exports.toAssistantUIMessage = toAssistantUIMessage;
-exports.toNetworkUIMessage = toNetworkUIMessage;
 exports.toUIMessage = toUIMessage;
 exports.useChat = useChat;
 exports.useMastraClient = useMastraClient;