@mastra/react 0.4.3-alpha.9 → 0.5.0-alpha.0

package/dist/index.cjs

@@ -4,6 +4,7 @@ var clientJs = require('@mastra/client-js');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var uuid = require('@lukeed/uuid');
+var messageList = require('@mastra/core/agent/message-list');
 var lucideReact = require('lucide-react');
 var tailwindMerge = require('tailwind-merge');
 var reactTooltip = require('@radix-ui/react-tooltip');
@@ -69,7 +70,7 @@ var MastraReactProvider = ({
   );
 };
 
-// src/lib/ai-sdk/utils/formatCompletionFeedback.ts
+// src/lib/mastra-db/formatCompletionFeedback.ts
 var formatBaseCompletionFeedback = (result, maxIterationReached, formatScorerHeading, incompleteMessage) => {
   const lines = [];
   lines.push("#### Completion Check Results");
@@ -114,29 +115,106 @@ var formatStreamCompletionFeedback = (result, maxIterationReached) => {
   );
 };
 
-// src/lib/ai-sdk/utils/toUIMessage.ts
-var markStreamingPartsDone = (message) => ({
+// src/lib/mastra-db/accumulator.ts
+var cloneMetadata = (metadata) => metadata ? { ...metadata } : {};
+var withParts = (message, parts) => ({
   ...message,
-  parts: message.parts.map((part) => {
-    if (typeof part === "object" && part !== null && "type" in part && "state" in part && part.state === "streaming" && (part.type === "text" || part.type === "reasoning")) {
-      return { ...part, state: "done" };
-    }
-    return part;
-  })
+  content: {
+    ...message.content,
+    parts
+  }
+});
+var withMetadata = (message, metadata) => ({
+  ...message,
+  content: {
+    ...message.content,
+    metadata
+  }
 });
+var replaceLast = (conversation, message) => [
+  ...conversation.slice(0, -1),
+  message
+];
+var replaceAt = (conversation, index, message) => [
+  ...conversation.slice(0, index),
+  message,
+  ...conversation.slice(index + 1)
+];
+var newAssistantMessage = (id, parts, metadata) => ({
+  id,
+  role: "assistant",
+  createdAt: /* @__PURE__ */ new Date(),
+  content: {
+    format: 2,
+    parts,
+    metadata: cloneMetadata(metadata)
+  }
+});
+var appendAssistantMessage = (conversation, id, parts, metadata) => [...conversation, newAssistantMessage(id, parts, metadata)];
+var isToolPart = (part) => part.type === "tool-invocation";
+var partTextId = (part) => part.type === "text" ? part.textId : void 0;
+var partState = (part) => part.state;
 var finishStreamingAssistantMessage = (conversation) => {
   const lastMessage = conversation[conversation.length - 1];
   if (!lastMessage || lastMessage.role !== "assistant") return conversation;
-  return [...conversation.slice(0, -1), markStreamingPartsDone(lastMessage)];
+  const nextParts = lastMessage.content.parts.map((part) => {
+    if ((part.type === "text" || part.type === "reasoning") && partState(part) === "streaming") {
+      return {
+        ...part,
+        state: "done"
+      };
+    }
+    return part;
+  });
+  return replaceLast(conversation, withParts(lastMessage, nextParts));
 };
-var appendAssistantMessage = (conversation, message, metadata) => [
-  ...conversation,
-  {
-    ...message,
-    role: "assistant",
-    metadata
+var locateToolPart = (messages, toolCallId, allowMetadataOnlyMatch) => {
+  const findIndex = (parts) => parts.findIndex((part) => isToolPart(part) && part.toolInvocation.toolCallId === toolCallId);
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage && lastMessage.role === "assistant") {
+    const idx = findIndex(lastMessage.content.parts);
+    if (idx !== -1) return { messageIndex: messages.length - 1, toolPartIndex: idx };
   }
-];
+  let count = 0;
+  const maxMessagesBack = 10;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (count > maxMessagesBack) break;
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    const idx = findIndex(message.content.parts);
+    if (idx !== -1) return { messageIndex: i, toolPartIndex: idx };
+    count++;
+  }
+  if (!allowMetadataOnlyMatch) return null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") return { messageIndex: i, toolPartIndex: -1 };
+  }
+  return null;
+};
+var mergeBgTaskMetadata = (existing, mode, args, otherMetadata) => {
+  const base = cloneMetadata(existing);
+  const existingBgTasks = base.backgroundTasks ?? {};
+  const nextBgTasks = { ...existingBgTasks };
+  if (args.perTaskEntry) {
+    const { toolCallId, startedAt, completedAt, taskId, suspendedAt } = args.perTaskEntry;
+    const prev = existingBgTasks[toolCallId] ?? { taskId };
+    nextBgTasks[toolCallId] = {
+      ...prev,
+      taskId,
+      ...startedAt !== void 0 ? { startedAt } : {},
+      ...completedAt !== void 0 ? { completedAt } : {},
+      ...suspendedAt !== void 0 ? { suspendedAt } : {}
+    };
+  }
+  const merged = {
+    ...base,
+    ...otherMetadata ?? {},
+    mode,
+    backgroundTasks: nextBgTasks
+  };
+  if (args.resetRunningCount) merged.runningBackgroundTasksCount = void 0;
+  return merged;
+};
 var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
   if (chunk.type === "workflow-start") {
     return {
@@ -146,10 +224,7 @@ var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
     };
   }
   if (chunk.type === "workflow-canceled") {
-    return {
-      ...prev,
-      status: "canceled"
-    };
+    return { ...prev, status: "canceled" };
   }
   if (chunk.type === "workflow-finish") {
     const finalStatus = chunk.payload.workflowStatus;
@@ -161,7 +236,7 @@ var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
       ...finalStatus === "success" && lastStep?.status === "success" ? { result: lastStep?.output } : finalStatus === "failed" && lastStep?.status === "failed" ? { error: lastStep?.error } : finalStatus === "tripwire" && chunk.payload.tripwire ? { tripwire: chunk.payload.tripwire } : {}
     };
   }
-  const { stepCallId, stepName, ...newPayload } = chunk.payload ?? {};
+  const { stepCallId: _stepCallId, stepName: _stepName, ...newPayload } = chunk.payload ?? {};
   const newSteps = {
     ...prev?.steps,
     [chunk.payload.id]: {
@@ -169,12 +244,7 @@ var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
       ...newPayload
     }
   };
-  if (chunk.type === "workflow-step-start") {
-    return {
-      ...prev,
-      steps: newSteps
-    };
-  }
+  if (chunk.type === "workflow-step-start") return { ...prev, steps: newSteps };
   if (chunk.type === "workflow-step-suspended") {
     const suspendedStepIds = Object.entries(newSteps).flatMap(
       ([stepId, stepResult]) => {
@@ -193,76 +263,40 @@ var mapWorkflowStreamChunkToWatchResult = (prev, chunk) => {
       suspended: suspendedStepIds
     };
   }
-  if (chunk.type === "workflow-step-waiting") {
+  if (chunk.type === "workflow-step-waiting") return { ...prev, status: "waiting", steps: newSteps };
+  if (chunk.type === "workflow-step-progress") {
     return {
       ...prev,
-      status: "waiting",
-      steps: newSteps
-    };
-  }
-  if (chunk.type === "workflow-step-progress") {
-    const progressSteps = {
-      ...prev?.steps,
-      [chunk.payload.id]: {
-        ...prev?.steps?.[chunk.payload.id],
-        foreachProgress: {
-          completedCount: chunk.payload.completedCount,
-          totalCount: chunk.payload.totalCount,
-          currentIndex: chunk.payload.currentIndex,
-          iterationStatus: chunk.payload.iterationStatus,
-          iterationOutput: chunk.payload.iterationOutput
+      steps: {
+        ...prev?.steps,
+        [chunk.payload.id]: {
+          ...prev?.steps?.[chunk.payload.id],
+          foreachProgress: {
+            completedCount: chunk.payload.completedCount,
+            totalCount: chunk.payload.totalCount,
+            currentIndex: chunk.payload.currentIndex,
+            iterationStatus: chunk.payload.iterationStatus,
+            iterationOutput: chunk.payload.iterationOutput
+          }
         }
       }
     };
-    return {
-      ...prev,
-      steps: progressSteps
-    };
-  }
-  if (chunk.type === "workflow-step-result") {
-    return {
-      ...prev,
-      steps: newSteps
-    };
   }
+  if (chunk.type === "workflow-step-result") return { ...prev, steps: newSteps };
   return prev;
 };
-function signalContentsToUserMessages(contents, metadata) {
-  if (typeof contents === "string") {
-    return [
-      {
-        id: `signal-${Date.now()}`,
-        role: "user",
-        parts: [{ type: "text", text: contents }],
-        metadata
-      }
-    ];
-  }
-  if (Array.isArray(contents)) {
-    return contents.flatMap((content2) => signalContentsToUserMessages(content2, metadata));
-  }
-  if (!contents || typeof contents !== "object") {
-    return [];
-  }
-  const message = contents;
-  if (message.role && message.role !== "user") {
-    return [];
-  }
-  const content = message.content;
-  if (typeof content === "string") {
-    return [
-      {
-        id: `signal-${Date.now()}`,
-        role: "user",
-        parts: [{ type: "text", text: content }],
-        metadata
-      }
-    ];
-  }
-  if (!Array.isArray(content)) {
-    return [];
-  }
-  const parts = content.flatMap((part) => {
+var signalContentsToUserMessages = (contents, metadata) => {
+  const makeUserMessage = (parts2) => ({
+    id: `signal-${Date.now()}`,
+    role: "user",
+    createdAt: /* @__PURE__ */ new Date(),
+    content: {
+      format: 2,
+      parts: parts2,
+      metadata: cloneMetadata(metadata)
+    }
+  });
+  const toMessagePart = (part) => {
     if (!part || typeof part !== "object") return [];
     const typedPart = part;
     if (typedPart.type === "text" && typeof typedPart.text === "string") {
@@ -290,19 +324,37 @@ function signalContentsToUserMessages(contents, metadata) {
       ];
     }
     return [];
-  });
-  return parts.length ? [
-    {
-      id: `signal-${Date.now()}`,
-      role: "user",
-      parts,
-      metadata
-    }
-  ] : [];
-}
-var toUIMessage = ({ chunk, conversation, metadata }) => {
+  };
+  if (typeof contents === "string") {
+    return [makeUserMessage([{ type: "text", text: contents }])];
+  }
+  if (Array.isArray(contents)) {
+    const parts2 = contents.flatMap(toMessagePart);
+    return parts2.length ? [makeUserMessage(parts2)] : contents.flatMap((content2) => signalContentsToUserMessages(content2, metadata));
+  }
+  if (!contents || typeof contents !== "object") return [];
+  const message = contents;
+  if (message.role && message.role !== "user") return [];
+  const content = message.content;
+  if (typeof content === "string") {
+    return [makeUserMessage([{ type: "text", text: content }])];
+  }
+  if (!Array.isArray(content)) return [];
+  const parts = content.flatMap(toMessagePart);
+  return parts.length ? [makeUserMessage(parts)] : [];
+};
+var makeToolInvocationPart = (invocation) => ({
+  type: "tool-invocation",
+  toolInvocation: invocation
+});
+var isTemplateLiteralPassthrough = (chunk) => chunk.type.startsWith("agent-execution-event-") || chunk.type.startsWith("workflow-execution-event-");
+var isDataChunk = (chunk) => chunk.type.startsWith("data-");
+var accumulateChunk = ({ chunk, conversation, metadata }) => {
   const result = [...conversation];
-  if (chunk.type.startsWith("data-")) {
+  if (isTemplateLiteralPassthrough(chunk)) {
+    return result;
+  }
+  if (isDataChunk(chunk)) {
     if (chunk.type === "data-user-message" && "data" in chunk && (chunk.data?.type === "user-message" || chunk.data?.type === "user")) {
       const signalId = chunk.data.id;
       if (typeof signalId === "string" && result.some((message) => message.id === signalId)) {
@@ -327,58 +379,37 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
     };
     const lastMessage = result[result.length - 1];
     if (!lastMessage || lastMessage.role !== "assistant") {
-      const newMessage = {
-        id: `data-${chunk.runId}-${Date.now()}`,
-        role: "assistant",
-        parts: [dataPart],
-        metadata
-      };
-      return [...result, newMessage];
+      return appendAssistantMessage(result, `data-${chunk.runId}-${Date.now()}`, [dataPart], metadata);
     }
-    const updatedMessage = {
-      ...lastMessage,
-      parts: [...lastMessage.parts, dataPart]
-    };
-    return [...result.slice(0, -1), updatedMessage];
+    return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, dataPart]));
   }
   switch (chunk.type) {
     case "tripwire": {
-      const newMessage = {
-        id: `tripwire-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "text",
-            text: chunk.payload.reason
-          }
-        ],
-        metadata: {
+      const newMessage = newAssistantMessage(
+        `tripwire-${chunk.runId + Date.now()}`,
+        [{ type: "text", text: chunk.payload.reason }],
+        {
           ...metadata,
           status: "tripwire",
           tripwire: {
+            reason: chunk.payload.reason,
             retry: chunk.payload.retry,
-            tripwirePayload: chunk.payload.metadata,
+            metadata: chunk.payload.metadata,
             processorId: chunk.payload.processorId
           }
         }
-      };
+      );
       return [...result, newMessage];
     }
     case "start": {
       const messageId = typeof chunk.payload.messageId === "string" ? chunk.payload.messageId : void 0;
       if (messageId && result.some((message) => message.id === messageId)) return result;
-      const newMessage = {
-        id: messageId ?? `start-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [],
-        metadata
-      };
-      return [...result, newMessage];
+      return [...result, newAssistantMessage(messageId ?? `start-${chunk.runId + Date.now()}`, [], metadata)];
     }
     case "text-start": {
       const lastMessage = result[result.length - 1];
       const textId = chunk.payload.id || `text-${Date.now()}`;
-      if (chunk.payload.id && lastMessage?.role === "assistant" && lastMessage.parts.some((part) => part.type === "text" && part.textId === textId)) {
+      if (chunk.payload.id && lastMessage?.role === "assistant" && lastMessage.content.parts.some((part) => part.type === "text" && partTextId(part) === textId)) {
         return result;
       }
       const newTextPart = {
@@ -391,41 +422,35 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
       if (!lastMessage || lastMessage.role !== "assistant") {
         return appendAssistantMessage(
           result,
-          { id: `start-${chunk.runId}-${Date.now()}`, parts: [newTextPart] },
+          `start-${chunk.runId}-${Date.now()}`,
+          [newTextPart],
           metadata
         );
       }
-      if (lastMessage.metadata?.completionResult) {
+      if (lastMessage.content.metadata?.completionResult) {
         return appendAssistantMessage(
           result,
-          { id: `start-${chunk.runId}-${Date.now()}`, parts: [newTextPart] },
+          `start-${chunk.runId}-${Date.now()}`,
+          [newTextPart],
           metadata
         );
       }
-      const parts = [...lastMessage.parts];
-      parts.push(newTextPart);
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(
+        result,
+        withParts(lastMessage, [...lastMessage.content.parts, newTextPart])
+      );
     }
     case "background-task-progress": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            mode: metadata.mode,
-            ...lastMessage.metadata,
-            runningBackgroundTasksCount: chunk.payload.runningCount
-          }
-        }
-      ];
+      return replaceLast(
+        result,
+        withMetadata(lastMessage, {
+          mode: metadata.mode,
+          ...lastMessage.content.metadata,
+          runningBackgroundTasksCount: chunk.payload.runningCount
+        })
+      );
     }
     case "text-delta": {
       const lastMessage = result[result.length - 1];
@@ -440,16 +465,15 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
         };
         return appendAssistantMessage(
           result,
-          { id: `text-${chunk.runId}-${Date.now()}`, parts: [newTextPart] },
+          `text-${chunk.runId}-${Date.now()}`,
+          [newTextPart],
           metadata
         );
       }
-      const parts = [...lastMessage.parts];
-      let textPartIndex = textId ? parts.findLastIndex((part) => part.type === "text" && part.textId === textId) : -1;
+      const parts = [...lastMessage.content.parts];
+      let textPartIndex = textId ? parts.findLastIndex((part) => part.type === "text" && partTextId(part) === textId) : -1;
       if (textPartIndex === -1) {
-        textPartIndex = parts.findLastIndex(
-          (part) => part.type === "text" && part.state === "streaming"
-        );
+        textPartIndex = parts.findLastIndex((part) => part.type === "text" && partState(part) === "streaming");
       }
       if (textPartIndex === -1) {
         const newTextPart = {
@@ -462,232 +486,370 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
         parts.push(newTextPart);
       } else {
         const textPart = parts[textPartIndex];
-        if (textPart.type === "text") {
-          const extendedTextPart = textPart;
-          const updatedTextPart = {
-            ...extendedTextPart,
-            text: extendedTextPart.text + chunk.payload.text,
-            state: "streaming"
-          };
-          parts[textPartIndex] = updatedTextPart;
-        }
+        parts[textPartIndex] = {
+          ...textPart,
+          text: textPart.text + chunk.payload.text,
+          state: "streaming"
+        };
       }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(result, withParts(lastMessage, parts));
+    }
+    case "text-end": {
+      return result;
     }
     case "reasoning-start": {
       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: "",
-              state: "streaming",
-              providerMetadata: chunk.payload.providerMetadata
-            }
-          ],
-          metadata
-        };
-        return [...result, newMessage];
-      }
-      const parts = [...lastMessage.parts];
-      parts.push({
+      const newReasoningPart = {
         type: "reasoning",
-        text: "",
+        reasoning: "",
         state: "streaming",
         providerMetadata: chunk.payload.providerMetadata
-      });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      };
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        return appendAssistantMessage(
+          result,
+          `reasoning-${chunk.runId + Date.now()}`,
+          [newReasoningPart],
+          metadata
+        );
+      }
+      return replaceLast(
+        result,
+        withParts(lastMessage, [...lastMessage.content.parts, newReasoningPart])
+      );
     }
     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
+        const newReasoningPart = {
+          type: "reasoning",
+          reasoning: chunk.payload.text,
+          state: "streaming",
+          providerMetadata: chunk.payload.providerMetadata
         };
-        return [...result, newMessage];
+        return appendAssistantMessage(
+          result,
+          `reasoning-${chunk.runId + Date.now()}`,
+          [newReasoningPart],
+          metadata
+        );
       }
-      const parts = [...lastMessage.parts];
-      const lastPartIndex = parts.length - 1;
-      const lastPart = parts[lastPartIndex];
+      const parts = [...lastMessage.content.parts];
+      const lastIndex = parts.length - 1;
+      const lastPart = parts[lastIndex];
       if (lastPart?.type === "reasoning") {
-        parts[lastPartIndex] = {
-          ...lastPart,
-          text: lastPart.text + chunk.payload.text,
+        const reasoningPart = lastPart;
+        parts[lastIndex] = {
+          ...reasoningPart,
+          reasoning: reasoningPart.reasoning + chunk.payload.text,
           state: "streaming"
         };
       } else {
-        parts.push({
+        const newReasoningPart = {
           type: "reasoning",
-          text: chunk.payload.text,
+          reasoning: chunk.payload.text,
           state: "streaming",
           providerMetadata: chunk.payload.providerMetadata
-        });
+        };
+        parts.push(newReasoningPart);
       }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(result, withParts(lastMessage, parts));
     }
     case "reasoning-end": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
-      const reasoningPartIndex = parts.findLastIndex(
-        (part) => part.type === "reasoning" && part.state === "streaming"
-      );
-      if (reasoningPartIndex === -1) return result;
-      const reasoningPart = parts[reasoningPartIndex];
-      if (reasoningPart.type !== "reasoning") return result;
-      const existingMetadata = reasoningPart.providerMetadata;
-      const endMetadata = chunk.payload.providerMetadata;
-      parts[reasoningPartIndex] = {
+      const parts = [...lastMessage.content.parts];
+      const reasoningIndex = parts.findLastIndex((part) => part.type === "reasoning" && partState(part) === "streaming");
+      if (reasoningIndex === -1) return result;
+      const reasoningPart = parts[reasoningIndex];
+      const existingMeta = reasoningPart.providerMetadata;
+      const endMeta = chunk.payload.providerMetadata;
+      parts[reasoningIndex] = {
         ...reasoningPart,
         state: "done",
-        ...existingMetadata || endMetadata ? {
-          providerMetadata: {
-            ...existingMetadata ?? {},
-            ...endMetadata ?? {}
-          }
-        } : {}
+        ...existingMeta || endMeta ? { providerMetadata: { ...existingMeta ?? {}, ...endMeta ?? {} } } : {}
       };
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(result, withParts(lastMessage, parts));
     }
-    case "tool-call": {
+    case "reasoning-signature": {
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") return result;
+      const parts = [...lastMessage.content.parts];
+      const reasoningIndex = parts.findLastIndex((part) => part.type === "reasoning");
+      if (reasoningIndex === -1) return result;
+      const reasoningPart = parts[reasoningIndex];
+      const existingMeta = reasoningPart.providerMetadata;
+      const sigMeta = chunk.payload.providerMetadata;
+      parts[reasoningIndex] = {
+        ...reasoningPart,
+        ...existingMeta || sigMeta ? { providerMetadata: { ...existingMeta ?? {}, ...sigMeta ?? {} } } : {}
+      };
+      return replaceLast(result, withParts(lastMessage, parts));
+    }
+    case "redacted-reasoning": {
       const lastMessage = result[result.length - 1];
+      const redactedData = chunk.payload.data;
+      const redactedPart = {
+        type: "reasoning",
+        reasoning: typeof redactedData === "string" ? redactedData : "",
+        state: "done",
+        redacted: true,
+        providerMetadata: chunk.payload.providerMetadata
+      };
       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
-            }
-          ],
+        return appendAssistantMessage(
+          result,
+          `redacted-reasoning-${chunk.runId + Date.now()}`,
+          [redactedPart],
           metadata
-        };
-        return [...result, newMessage];
+        );
       }
-      const parts = [...lastMessage.parts];
-      parts.push({
-        type: "dynamic-tool",
-        toolName: chunk.payload.toolName,
+      return replaceLast(
+        result,
+        withParts(lastMessage, [...lastMessage.content.parts, redactedPart])
+      );
+    }
+    case "tool-call": {
+      const invocation = {
+        state: "call",
         toolCallId: chunk.payload.toolCallId,
-        state: "input-available",
-        input: chunk.payload.args,
-        callProviderMetadata: chunk.payload.providerMetadata
-      });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
+        toolName: chunk.payload.toolName,
+        args: chunk.payload.args
+      };
+      const newPart = {
+        ...makeToolInvocationPart(invocation),
+        providerMetadata: chunk.payload.providerMetadata
+      };
+      const existing = locateToolPart(result, chunk.payload.toolCallId, false);
+      if (existing && existing.toolPartIndex >= 0) {
+        const { messageIndex, toolPartIndex } = existing;
+        const targetMessage = result[messageIndex];
+        if (targetMessage && targetMessage.role === "assistant") {
+          const parts = [...targetMessage.content.parts];
+          const prev = parts[toolPartIndex];
+          if (isToolPart(prev)) {
+            const { argsText: _argsText, ...rest } = prev;
+            parts[toolPartIndex] = {
+              ...rest,
+              toolInvocation: {
+                ...prev.toolInvocation,
+                state: "call",
+                toolName: chunk.payload.toolName,
+                toolCallId: chunk.payload.toolCallId,
+                args: chunk.payload.args
+              },
+              providerMetadata: chunk.payload.providerMetadata ?? prev.providerMetadata
+            };
+            return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+          }
         }
-      ];
+      }
+      const lastMessage = result[result.length - 1];
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        return appendAssistantMessage(result, `tool-call-${chunk.runId + Date.now()}`, [newPart], metadata);
+      }
+      return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newPart]));
     }
-    case "tool-error":
-    case "tool-result":
-    case "background-task-completed":
-    case "background-task-failed": {
-      const isBgTaskEvent = chunk.type === "background-task-completed" || chunk.type === "background-task-failed";
-      const location = locateToolPart(result, chunk.payload.toolCallId, isBgTaskEvent);
-      if (!location) return result;
+    case "tool-call-input-streaming-start": {
+      const lastMessage = result[result.length - 1];
+      const invocation = {
+        state: "partial-call",
+        toolCallId: chunk.payload.toolCallId,
+        toolName: chunk.payload.toolName,
+        args: {}
+      };
+      const newPart = {
+        ...makeToolInvocationPart(invocation),
+        argsText: ""
+      };
+      if (!lastMessage || lastMessage.role !== "assistant") {
+        return appendAssistantMessage(
+          result,
+          `tool-call-streaming-${chunk.runId + Date.now()}`,
+          [newPart],
+          metadata
+        );
+      }
+      return replaceLast(result, withParts(lastMessage, [...lastMessage.content.parts, newPart]));
+    }
+    case "tool-call-delta": {
+      const location = locateToolPart(result, chunk.payload.toolCallId, false);
+      if (!location || location.toolPartIndex < 0) return result;
       const { messageIndex, toolPartIndex } = location;
       const targetMessage = result[messageIndex];
       if (!targetMessage || targetMessage.role !== "assistant") return result;
-      const parts = [...targetMessage.parts];
-      const toolPart = toolPartIndex >= 0 ? parts[toolPartIndex] : void 0;
-      if (toolPart && (toolPart.type === "dynamic-tool" || typeof toolPart.type === "string" && toolPart.type.startsWith("tool-"))) {
-        const toolName = "toolName" in toolPart && typeof toolPart.toolName === "string" ? toolPart.toolName : typeof toolPart.type === "string" && toolPart.type.startsWith("tool-") ? toolPart.type.substring(5) : "";
-        const toolCallId = toolPart.toolCallId;
-        if ((chunk.type === "tool-result" || chunk.type === "background-task-completed") && chunk.payload.isError || chunk.type === "tool-error" || chunk.type === "background-task-failed") {
-          const error = chunk.type === "tool-error" || chunk.type === "background-task-failed" ? chunk.payload.error : chunk.payload.result;
-          parts[toolPartIndex] = {
-            type: "dynamic-tool",
-            toolName,
-            toolCallId,
-            state: "output-error",
-            input: toolPart.input,
-            errorText: typeof error === "string" ? error : error instanceof Error ? error.message : error?.message ?? String(error),
-            callProviderMetadata: chunk.payload.providerMetadata
+      const parts = [...targetMessage.content.parts];
+      const toolPart = parts[toolPartIndex];
+      if (!isToolPart(toolPart)) return result;
+      const nextArgsText = (toolPart.argsText ?? "") + (chunk.payload.argsTextDelta ?? "");
+      parts[toolPartIndex] = {
+        ...toolPart,
+        argsText: nextArgsText,
+        toolInvocation: {
+          ...toolPart.toolInvocation,
+          state: "partial-call"
+        }
+      };
+      return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+    }
+    case "tool-call-input-streaming-end": {
+      const location = locateToolPart(result, chunk.payload.toolCallId, false);
+      if (!location || location.toolPartIndex < 0) return result;
+      const { messageIndex, toolPartIndex } = location;
+      const targetMessage = result[messageIndex];
+      if (!targetMessage || targetMessage.role !== "assistant") return result;
+      const parts = [...targetMessage.content.parts];
+      const toolPart = parts[toolPartIndex];
+      if (!isToolPart(toolPart)) return result;
+      let parsedArgs = {};
+      const argsText = toolPart.argsText;
+      if (typeof argsText === "string" && argsText.length > 0) {
+        try {
+          const maybe = JSON.parse(argsText);
+          if (maybe && typeof maybe === "object" && !Array.isArray(maybe)) {
+            parsedArgs = maybe;
+          }
+        } catch {
+          parsedArgs = {};
+        }
+      }
+      parts[toolPartIndex] = {
+        ...toolPart,
+        toolInvocation: {
+          ...toolPart.toolInvocation,
+          state: "call",
+          args: parsedArgs
+        }
+      };
+      return replaceAt(result, messageIndex, withParts(targetMessage, parts));
+    }
+    case "tool-error":
+    case "tool-result":
+    case "background-task-completed":
+    case "background-task-failed": {
+      const isBgTaskEvent = chunk.type === "background-task-completed" || chunk.type === "background-task-failed";
+      const location = locateToolPart(result, chunk.payload.toolCallId, isBgTaskEvent);
+      if (!location) return result;
+      const { messageIndex, toolPartIndex } = location;
+      const targetMessage = result[messageIndex];
+      if (!targetMessage || targetMessage.role !== "assistant") return result;
+      const parts = [...targetMessage.content.parts];
+      const toolPart = toolPartIndex >= 0 ? parts[toolPartIndex] : void 0;
+      let payloadResult;
+      let payloadError;
+      let payloadIsError = false;
+      let payloadProviderMetadata;
+      let payloadCompletedAt;
+      let payloadTaskId;
+      switch (chunk.type) {
+        case "tool-result":
+          payloadResult = chunk.payload.result;
+          payloadIsError = Boolean(chunk.payload.isError);
+          payloadProviderMetadata = chunk.payload.providerMetadata;
+          break;
+        case "tool-error":
+          payloadError = chunk.payload.error;
+          payloadProviderMetadata = chunk.payload.providerMetadata;
+          break;
+        case "background-task-completed":
+          payloadResult = chunk.payload.result;
+          payloadCompletedAt = chunk.payload.completedAt;
+          payloadTaskId = chunk.payload.taskId;
+          break;
+        case "background-task-failed":
+          payloadError = chunk.payload.error;
+          payloadCompletedAt = chunk.payload.completedAt;
+          payloadTaskId = chunk.payload.taskId;
+          break;
+      }
+      if (toolPart && isToolPart(toolPart)) {
+        const { toolName, toolCallId, args } = toolPart.toolInvocation;
+        const providerMeta = payloadProviderMetadata ?? toolPart.providerMetadata;
+        const isError = chunk.type === "tool-error" || chunk.type === "background-task-failed" || payloadIsError;
+        if (isError) {
+          const error = chunk.type === "tool-error" || chunk.type === "background-task-failed" ? payloadError : payloadResult;
+          const errorText = typeof error === "string" ? error : error instanceof Error ? error.message : error?.message ?? String(error);
+          parts[toolPartIndex] = {
+            ...toolPart,
+            providerMetadata: providerMeta,
+            toolInvocation: {
+              state: "output-error",
+              toolCallId,
+              toolName,
+              args,
+              errorText
+            }
           };
         } else {
-          const isWorkflow = Boolean(chunk.payload.result?.result?.steps);
-          const isAgent = chunk?.from === "AGENT";
+          const resultObj = payloadResult;
+          const existingResult = toolPart.toolInvocation.state === "partial-call" || toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
+          const existingLooksLikeWorkflow = Boolean(
+            existingResult && typeof existingResult === "object" && "steps" in existingResult
+          );
+          const isWorkflow = Boolean(resultObj?.result?.steps) || toolName?.startsWith("workflow-") || existingLooksLikeWorkflow;
+          const isAgent = chunk.from === "AGENT";
           let output;
           if (isWorkflow) {
-            output = chunk.payload.result?.result;
+            const accumulated = existingLooksLikeWorkflow && existingResult && typeof existingResult === "object" ? existingResult : void 0;
+            const payloadWorkflow = resultObj?.result && typeof resultObj.result === "object" ? resultObj.result : void 0;
+            if (accumulated || payloadWorkflow) {
+              output = {
+                ...accumulated ?? {},
+                ...payloadWorkflow ?? {},
+                // Preserve `steps` from accumulated state when the terminal
+                // payload doesn't carry them.
+                steps: payloadWorkflow?.steps ?? accumulated?.steps ?? [],
+                status: payloadWorkflow?.status ?? accumulated?.status ?? "success",
+                // Surface the terminal scalar output without losing history.
+                output: payloadResult
+              };
+            } else {
+              output = payloadResult;
+            }
           } else if (isAgent) {
-            const existingOutput = parts[toolPartIndex].output;
+            const existingOutput = toolPart.toolInvocation.state === "result" ? toolPart.toolInvocation.result : void 0;
+            const existingChild = existingOutput?.childMessages;
             output = existingOutput ? {
-              ...chunk.payload.result,
-              childMessages: existingOutput.childMessages?.length ? existingOutput.childMessages : chunk.payload.result?.childMessages
-            } : chunk.payload.result;
+              ...payloadResult,
+              childMessages: existingChild?.length ? existingChild : resultObj?.childMessages
+            } : payloadResult;
           } else {
-            output = chunk.payload.result;
+            output = payloadResult;
           }
           parts[toolPartIndex] = {
-            type: "dynamic-tool",
-            toolName,
-            toolCallId,
-            state: "output-available",
-            input: toolPart.input,
-            output,
-            callProviderMetadata: chunk.payload.providerMetadata
+            ...toolPart,
+            providerMetadata: providerMeta,
+            toolInvocation: {
+              state: "result",
+              toolCallId,
+              toolName,
+              args,
+              result: output
+            }
           };
         }
       }
-      const nextMessage = {
-        ...targetMessage,
-        parts,
-        metadata: mergeBgTaskMetadata(targetMessage.metadata, metadata.mode, {
+      const nextMetadata = mergeBgTaskMetadata(
+        targetMessage.content.metadata,
+        metadata.mode,
+        {
           resetRunningCount: isBgTaskEvent,
-          perTaskEntry: isBgTaskEvent ? {
+          perTaskEntry: isBgTaskEvent && payloadTaskId ? {
             toolCallId: chunk.payload.toolCallId,
-            completedAt: chunk.payload.completedAt,
-            taskId: chunk.payload.taskId
+            completedAt: payloadCompletedAt,
+            taskId: payloadTaskId
           } : void 0
-        })
+        }
+      );
+      const nextMessage = {
+        ...targetMessage,
+        content: {
+          ...targetMessage.content,
+          parts,
+          metadata: nextMetadata
+        }
       };
-      return [...result.slice(0, messageIndex), nextMessage, ...result.slice(messageIndex + 1)];
+      return replaceAt(result, messageIndex, nextMessage);
     }
     case "background-task-running": {
       const location = locateToolPart(result, chunk.payload.toolCallId, true);
@@ -695,20 +857,18 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
       const { messageIndex } = location;
       const targetMessage = result[messageIndex];
       if (!targetMessage || targetMessage.role !== "assistant") return result;
-      return [
-        ...result.slice(0, messageIndex),
+      const nextMetadata = mergeBgTaskMetadata(
+        targetMessage.content.metadata,
+        metadata.mode,
         {
-          ...targetMessage,
-          metadata: mergeBgTaskMetadata(targetMessage.metadata, metadata.mode, {
-            perTaskEntry: {
-              toolCallId: chunk.payload.toolCallId,
-              startedAt: chunk.payload.startedAt,
-              taskId: chunk.payload.taskId
-            }
-          })
-        },
-        ...result.slice(messageIndex + 1)
-      ];
+          perTaskEntry: {
+            toolCallId: chunk.payload.toolCallId,
+            startedAt: chunk.payload.startedAt,
+            taskId: chunk.payload.taskId
+          }
+        }
+      );
+      return replaceAt(result, messageIndex, withMetadata(targetMessage, nextMetadata));
     }
     case "tool-output":
     case "background-task-output": {
@@ -718,47 +878,41 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
       const { messageIndex, toolPartIndex } = location;
       const targetMessage = result[messageIndex];
       if (!targetMessage || targetMessage.role !== "assistant") return result;
-      const parts = [...targetMessage.parts];
+      const parts = [...targetMessage.content.parts];
       const toolPart = parts[toolPartIndex];
-      if (toolPart.type === "dynamic-tool" || typeof toolPart.type === "string" && toolPart.type.startsWith("tool-")) {
-        const toolName = "toolName" in toolPart && typeof toolPart.toolName === "string" ? toolPart.toolName : typeof toolPart.type === "string" && toolPart.type.startsWith("tool-") ? toolPart.type.substring(5) : "";
-        const toolCallId = toolPart.toolCallId;
-        const input = toolPart.input;
-        const payloadOutput = chunk.type === "background-task-output" ? chunk.payload.payload.payload.output : chunk.payload.output;
-        if (payloadOutput?.type?.startsWith("workflow-")) {
-          const existingWorkflowState = toolPart.output || {};
-          const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, payloadOutput);
-          parts[toolPartIndex] = {
-            type: "dynamic-tool",
-            toolName,
+      if (!isToolPart(toolPart)) return result;
+      const { toolName, toolCallId, args } = toolPart.toolInvocation;
+      const payloadOutput = chunk.type === "background-task-output" ? chunk.payload.payload.payload.output : chunk.payload.output;
+      if (payloadOutput?.type?.startsWith("workflow-")) {
+        const existingWorkflowState = toolPart.toolInvocation.result || {};
+        const updated = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, payloadOutput);
+        parts[toolPartIndex] = {
+          ...toolPart,
+          toolInvocation: {
+            state: "partial-call",
             toolCallId,
-            state: "input-streaming",
-            input,
-            output: updatedWorkflowState
-          };
-        } else if (payloadOutput?.from === "AGENT" || payloadOutput?.from === "USER" && payloadOutput?.payload?.output?.type?.startsWith("workflow-")) {
-          return toUIMessageFromAgent(payloadOutput, conversation, metadata, toolCallId, toolName);
-        } else {
-          const currentOutput = toolPart.output || [];
-          const existingOutput = Array.isArray(currentOutput) ? currentOutput : [];
-          parts[toolPartIndex] = {
-            type: "dynamic-tool",
             toolName,
+            args,
+            result: updated
+          }
+        };
+      } else if (payloadOutput?.from === "AGENT" || payloadOutput?.from === "USER" && payloadOutput?.payload?.output?.type?.startsWith("workflow-")) {
+        return accumulateAgentChunk(payloadOutput, result, metadata, toolCallId, toolName);
+      } else {
+        const currentResult = toolPart.toolInvocation.result;
+        const existing = Array.isArray(currentResult) ? currentResult : [];
+        parts[toolPartIndex] = {
+          ...toolPart,
+          toolInvocation: {
+            state: "partial-call",
             toolCallId,
-            state: "input-streaming",
-            input,
-            output: [...existingOutput, payloadOutput]
-          };
-        }
+            toolName,
+            args,
+            result: [...existing, payloadOutput]
+          }
+        };
       }
-      return [
-        ...result.slice(0, messageIndex),
-        {
-          ...targetMessage,
-          parts
-        },
-        ...result.slice(messageIndex + 1)
-      ];
+      return replaceAt(result, messageIndex, withParts(targetMessage, parts));
     }
     case "is-task-complete": {
       if (chunk.payload.suppressFeedback) return result;
@@ -770,36 +924,29 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
           timedOut: chunk.payload.timedOut},
         chunk.payload.maxIterationReached
       );
-      const newMessage = {
-        id: `is-task-complete-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "text",
-            text: feedback
-          }
-        ],
-        metadata: {
+      const newMessage = newAssistantMessage(
+        `is-task-complete-${chunk.runId + Date.now()}`,
+        [{ type: "text", text: feedback }],
+        {
           ...metadata,
-          completionResult: {
-            passed: chunk.payload.passed
-          }
+          completionResult: { passed: chunk.payload.passed }
         }
-      };
+      );
       return [...result, newMessage];
     }
     case "source": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
+      const parts = [...lastMessage.content.parts];
       if (chunk.payload.sourceType === "url") {
-        parts.push({
+        const sourceUrlPart = {
           type: "source-url",
           sourceId: chunk.payload.id,
           url: chunk.payload.url || "",
           title: chunk.payload.title,
           providerMetadata: chunk.payload.providerMetadata
-        });
+        };
+        parts.push(sourceUrlPart);
       } else if (chunk.payload.sourceType === "document") {
         parts.push({
           type: "source-document",
@@ -810,18 +957,12 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
           providerMetadata: chunk.payload.providerMetadata
         });
       }
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(result, withParts(lastMessage, parts));
     }
     case "file": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const parts = [...lastMessage.parts];
+      const parts = [...lastMessage.content.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)}`;
@@ -835,27 +976,22 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
         url,
         providerMetadata: chunk.payload.providerMetadata
       });
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
+      return replaceLast(result, withParts(lastMessage, parts));
     }
     case "tool-call-approval": {
       const lastMessage = result[result.length - 1];
       if (!lastMessage || lastMessage.role !== "assistant") return result;
-      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "stream" ? lastMessage.metadata?.requireApprovalMetadata : {};
-      return [
-        ...result.slice(0, -1),
-        {
-          ...lastMessage,
+      const existingMeta = lastMessage.content.metadata ?? {};
+      const lastRequireApproval = existingMeta.mode === "stream" ? existingMeta.requireApprovalMetadata ?? {} : {};
+      return replaceLast(result, {
+        ...lastMessage,
+        content: {
+          ...lastMessage.content,
           metadata: {
-            ...lastMessage.metadata,
+            ...existingMeta,
             mode: "stream",
             requireApprovalMetadata: {
-              ...lastRequireApprovalMetadata,
+              ...lastRequireApproval,
               [chunk.payload.toolName]: {
                 toolCallId: chunk.payload.toolCallId,
                 toolName: chunk.payload.toolName,
@@ -864,1099 +1000,644 @@ var toUIMessage = ({ chunk, conversation, metadata }) => {
             }
           }
         }
-      ];
+      });
     }
     case "tool-call-suspended":
     case "background-task-suspended": {
       const isBgTaskEvent = chunk.type === "background-task-suspended";
-      const location = isBgTaskEvent ? locateToolPart(result, chunk.payload.toolCallId, isBgTaskEvent) : { messageIndex: result.length - 1 };
+      let suspToolCallId;
+      let suspToolName;
+      let suspArgs;
+      let suspPayload;
+      let suspSuspendedAt;
+      let suspTaskId;
+      if (chunk.type === "background-task-suspended") {
+        suspToolCallId = chunk.payload.toolCallId;
+        suspToolName = chunk.payload.toolName;
+        suspArgs = chunk.payload.args;
+        suspPayload = chunk.payload.suspendPayload;
+        suspSuspendedAt = chunk.payload.suspendedAt;
+        suspTaskId = chunk.payload.taskId;
+      } else {
+        suspToolCallId = chunk.payload.toolCallId;
+        suspToolName = chunk.payload.toolName;
+        suspArgs = chunk.payload.args;
+        suspPayload = chunk.payload.suspendPayload;
+      }
+      const location = isBgTaskEvent ? locateToolPart(result, suspToolCallId, true) : { messageIndex: result.length - 1 };
       if (!location) return result;
       const { messageIndex } = location;
       const targetMessage = result[messageIndex];
       if (!targetMessage || targetMessage.role !== "assistant") return result;
-      const lastSuspendedTools = targetMessage.metadata?.mode === "stream" ? targetMessage.metadata?.suspendedTools : {};
-      const nextMessage = {
-        ...targetMessage,
-        metadata: mergeBgTaskMetadata(
-          targetMessage.metadata,
-          "stream",
-          {
-            resetRunningCount: isBgTaskEvent,
-            perTaskEntry: isBgTaskEvent ? {
-              toolCallId: chunk.payload.toolCallId,
-              suspendedAt: chunk.payload.suspendedAt,
-              taskId: chunk.payload.taskId
-            } : void 0
-          },
-          {
-            suspendedTools: {
-              ...lastSuspendedTools,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                suspendPayload: chunk.payload.suspendPayload,
-                runId: chunk.runId
-              }
+      const existingMeta = targetMessage.content.metadata ?? {};
+      const lastSuspendedTools = existingMeta.mode === "stream" ? existingMeta.suspendedTools ?? {} : {};
+      const nextMetadata = mergeBgTaskMetadata(
+        existingMeta,
+        "stream",
+        {
+          resetRunningCount: isBgTaskEvent,
+          perTaskEntry: isBgTaskEvent && suspTaskId ? {
+            toolCallId: suspToolCallId,
+            suspendedAt: suspSuspendedAt,
+            taskId: suspTaskId
+          } : void 0
+        },
+        {
+          suspendedTools: {
+            ...lastSuspendedTools,
+            [suspToolName]: {
+              toolCallId: suspToolCallId,
+              toolName: suspToolName,
+              args: suspArgs,
+              suspendPayload: suspPayload,
+              runId: chunk.runId
             }
           }
-        )
-      };
-      return [...result.slice(0, messageIndex), nextMessage, ...result.slice(messageIndex + 1)];
+        }
+      );
+      return replaceAt(result, messageIndex, withMetadata(targetMessage, nextMetadata));
     }
     case "finish":
     case "abort": {
       return finishStreamingAssistantMessage(result);
     }
     case "error": {
-      const newMessage = {
-        id: `error-${chunk.runId + Date.now()}`,
-        role: "assistant",
-        parts: [
+      const newMessage = newAssistantMessage(
+        `error-${chunk.runId + Date.now()}`,
+        [
           {
             type: "text",
             text: typeof chunk.payload.error === "string" ? chunk.payload.error : JSON.stringify(chunk.payload.error)
           }
         ],
-        metadata: {
+        {
           ...metadata,
           status: "error"
         }
-      };
+      );
       return [...result, newMessage];
     }
-    // For all other chunk types, return conversation unchanged
-    default:
+    // ----- Lifecycle / step / framing chunks (not surfaced on DB messages) -----
+    case "step-start":
+    case "step-finish":
+    case "step-output":
+    case "raw":
+    case "watch":
+    case "response-metadata":
+      return result;
+    // ----- Object chunks (object/object-result are not stored on DB messages) -----
+    case "object":
+    case "object-result":
       return result;
+    // ----- Background-task lifecycle markers not folded into messages -----
+    case "background-task-started":
+    case "background-task-cancelled":
+    case "background-task-resumed":
+      return result;
+    // ----- Workflow lifecycle passthroughs (handled by mapWorkflowStreamChunkToWatchResult inside tool-output) -----
+    case "workflow-start":
+    case "workflow-finish":
+    case "workflow-canceled":
+    case "workflow-paused":
+    case "workflow-step-start":
+    case "workflow-step-finish":
+    case "workflow-step-suspended":
+    case "workflow-step-waiting":
+    case "workflow-step-output":
+    case "workflow-step-progress":
+    case "workflow-step-result":
+      return result;
+    // ----- Nested-execution / routing / network passthroughs -----
+    case "agent-execution-start":
+    case "agent-execution-approval":
+    case "agent-execution-suspended":
+    case "agent-execution-end":
+    case "agent-execution-abort":
+    case "tool-execution-start":
+    case "tool-execution-end":
+    case "tool-execution-approval":
+    case "tool-execution-suspended":
+    case "tool-execution-abort":
+    case "routing-agent-start":
+    case "routing-agent-text-delta":
+    case "routing-agent-text-start":
+    case "routing-agent-end":
+    case "routing-agent-abort":
+    case "workflow-execution-start":
+    case "workflow-execution-end":
+    case "workflow-execution-suspended":
+    case "workflow-execution-abort":
+    case "network-execution-event-step-finish":
+    case "network-execution-event-finish":
+    case "network-validation-start":
+    case "network-validation-end":
+    case "network-object":
+    case "network-object-result":
+      return result;
+    default:
+      return assertExhaustive(chunk, result);
   }
 };
-var toUIMessageFromAgent = (chunk, conversation, metadata, parentToolCallId, parentToolName) => {
+var assertExhaustive = (_chunk, fallback) => fallback;
+var accumulateAgentChunk = (chunk, conversation, _metadata, parentToolCallId, parentToolName) => {
   const lastMessage = conversation[conversation.length - 1];
   if (!lastMessage || lastMessage.role !== "assistant") return conversation;
-  const parts = [...lastMessage.parts];
+  const parts = [...lastMessage.content.parts];
+  const findToolPartIndex = () => parts.findIndex(
+    (part) => isToolPart(part) && (parentToolCallId && part.toolInvocation.toolCallId === parentToolCallId || parentToolName && part.toolInvocation.toolName === parentToolName)
+  );
   if (chunk.type === "text-delta") {
     const agentChunk = chunk.payload;
-    const toolPartIndex = parts.findIndex(
-      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
-    );
+    const toolPartIndex = findToolPartIndex();
     if (toolPartIndex === -1) return conversation;
     const toolPart = parts[toolPartIndex];
-    const childMessages = toolPart?.output?.childMessages || [];
+    const existingResult = toolPart.toolInvocation.result || {};
+    const childMessages = existingResult.childMessages || [];
     const lastChildMessage = childMessages[childMessages.length - 1];
     const textMessage = { type: "text", content: (lastChildMessage?.content || "") + agentChunk.text };
-    const nextMessages = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
+    const nextChildren = lastChildMessage?.type === "text" ? [...childMessages.slice(0, -1), textMessage] : [...childMessages, textMessage];
     parts[toolPartIndex] = {
       ...toolPart,
-      output: {
-        childMessages: nextMessages
+      toolInvocation: {
+        ...toolPart.toolInvocation,
+        result: { ...existingResult, childMessages: nextChildren }
       }
     };
   } else if (chunk.type === "tool-call") {
     const agentChunk = chunk.payload;
-    const toolPartIndex = parts.findIndex(
-      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
-    );
+    const toolPartIndex = findToolPartIndex();
     if (toolPartIndex === -1) return conversation;
     const toolPart = parts[toolPartIndex];
-    const childMessages = toolPart?.output?.childMessages || [];
+    const existingResult = toolPart.toolInvocation.result || {};
+    const childMessages = existingResult.childMessages || [];
     parts[toolPartIndex] = {
       ...toolPart,
-      output: {
-        ...toolPart?.output,
-        childMessages: [
-          ...childMessages,
-          {
-            type: "tool",
-            toolCallId: agentChunk.toolCallId,
-            toolName: agentChunk.toolName,
-            args: agentChunk.args
-          }
-        ]
+      toolInvocation: {
+        ...toolPart.toolInvocation,
+        result: {
+          ...existingResult,
+          childMessages: [
+            ...childMessages,
+            {
+              type: "tool",
+              toolCallId: agentChunk.toolCallId,
+              toolName: agentChunk.toolName,
+              args: agentChunk.args
+            }
+          ]
+        }
       }
     };
   } else if (chunk.type === "tool-output") {
     const agentChunk = chunk.payload;
-    const toolPartIndex = parts.findIndex(
-      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
-    );
+    const toolPartIndex = findToolPartIndex();
     if (toolPartIndex === -1) return conversation;
     const toolPart = parts[toolPartIndex];
     if (agentChunk?.output?.type?.startsWith("workflow-")) {
-      const childMessages = toolPart?.output?.childMessages || [];
-      const lastToolIndex = childMessages.length - 1;
-      const currentMessage = childMessages[lastToolIndex];
+      const existingResult = toolPart.toolInvocation.result || {};
+      const childMessages = existingResult.childMessages || [];
+      const lastIndex = childMessages.length - 1;
+      const currentMessage = childMessages[lastIndex];
       const actualExistingWorkflowState = currentMessage?.toolOutput || {};
-      const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(actualExistingWorkflowState, agentChunk.output);
-      if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+      const updated = mapWorkflowStreamChunkToWatchResult(actualExistingWorkflowState, agentChunk.output);
+      if (lastIndex >= 0 && childMessages[lastIndex]?.type === "tool") {
         parts[toolPartIndex] = {
           ...toolPart,
-          output: {
-            ...toolPart?.output,
-            childMessages: [
-              ...childMessages.slice(0, -1),
-              {
-                ...currentMessage,
-                toolOutput: { ...updatedWorkflowState, runId: agentChunk.output.runId }
-              }
-            ]
+          toolInvocation: {
+            ...toolPart.toolInvocation,
+            result: {
+              ...existingResult,
+              childMessages: [
+                ...childMessages.slice(0, -1),
+                {
+                  ...currentMessage,
+                  toolOutput: { ...updated, runId: agentChunk.output.runId }
+                }
+              ]
+            }
           }
         };
       }
     }
   } else if (chunk.type === "tool-result") {
     const agentChunk = chunk.payload;
-    const toolPartIndex = parts.findIndex(
-      (part) => part.type === "dynamic-tool" && (parentToolCallId && part.toolCallId === parentToolCallId || parentToolName && part.toolName === parentToolName)
-    );
+    const toolPartIndex = findToolPartIndex();
     if (toolPartIndex === -1) return conversation;
     const toolPart = parts[toolPartIndex];
-    const childMessages = toolPart?.output?.childMessages || [];
-    const lastToolIndex = childMessages.length - 1;
+    const existingResult = toolPart.toolInvocation.result || {};
+    const childMessages = existingResult.childMessages || [];
+    const lastIndex = childMessages.length - 1;
     const isWorkflow = agentChunk?.toolName?.startsWith("workflow-");
-    if (lastToolIndex >= 0 && childMessages[lastToolIndex]?.type === "tool") {
+    if (lastIndex >= 0 && childMessages[lastIndex]?.type === "tool") {
       parts[toolPartIndex] = {
         ...toolPart,
-        output: {
-          ...toolPart?.output,
-          childMessages: [
-            ...childMessages.slice(0, -1),
-            {
-              ...childMessages[lastToolIndex],
-              toolOutput: isWorkflow ? { ...agentChunk.result?.result, runId: agentChunk.result?.runId } : agentChunk.result
-            }
-          ]
+        toolInvocation: {
+          ...toolPart.toolInvocation,
+          result: {
+            ...existingResult,
+            childMessages: [
+              ...childMessages.slice(0, -1),
+              {
+                ...childMessages[lastIndex],
+                toolOutput: isWorkflow ? { ...agentChunk.result?.result, runId: agentChunk.result?.runId } : agentChunk.result
+              }
+            ]
+          }
         }
       };
     }
   }
-  return [
-    ...conversation.slice(0, -1),
-    {
-      ...lastMessage,
-      parts
-    }
-  ];
+  return replaceLast(conversation, withParts(lastMessage, parts));
 };
-var findMessageIndexByToolCallId = (messages, toolCallId) => {
-  let count = 0;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const maxMessagesBack = 10;
-    if (count > maxMessagesBack) {
-      return -1;
-    }
-    const message = messages[i];
-    if (message.role !== "assistant") {
-      continue;
-    }
-    for (const part of message.parts) {
-      if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) {
-        return i;
-      }
-    }
-    count++;
-  }
-  return -1;
+var networkMode = (metadata) => ({ ...metadata, mode: "network" });
+var findPartIndex = (parts, predicate) => parts.findIndex(predicate);
+var isDynamicToolPart = (part) => part.type === "dynamic-tool";
+var lastAssistant = (conversation) => {
+  const last = conversation[conversation.length - 1];
+  return last && last.role === "assistant" ? last : void 0;
 };
-var locateToolPart = (messages, toolCallId, allowMetadataOnlyMatch) => {
-  const lastMessage = messages[messages.length - 1];
-  if (lastMessage && lastMessage.role === "assistant") {
-    const toolPartIndex2 = lastMessage.parts.findIndex(
-      (part) => (part.type === "dynamic-tool" || typeof part.type === "string" && part.type.startsWith("tool-")) && "toolCallId" in part && part.toolCallId === toolCallId
-    );
-    if (toolPartIndex2 !== -1) {
-      return { messageIndex: messages.length - 1, toolPartIndex: toolPartIndex2 };
+var tryParseRoutingDecision = (buffered) => {
+  const trimmed = buffered.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
     }
+    return null;
+  } catch {
+    return null;
   }
-  const messageIndex = findMessageIndexByToolCallId(messages, toolCallId);
-  if (messageIndex === -1) return null;
-  const message = messages[messageIndex];
-  if (!message || message.role !== "assistant") return null;
-  const toolPartIndex = message.parts.findIndex(
-    (part) => (part.type === "dynamic-tool" || typeof part.type === "string" && part.type.startsWith("tool-")) && "toolCallId" in part && part.toolCallId === toolCallId
-  );
-  if (toolPartIndex === -1) {
-    return allowMetadataOnlyMatch ? { messageIndex, toolPartIndex: -1 } : null;
-  }
-  return { messageIndex, toolPartIndex };
-};
-var mergeBgTaskMetadata = (existing, mode, args, otherMetadata) => {
-  const existingAny = existing ?? {};
-  const existingBgTasks = existingAny.backgroundTasks ?? {};
-  const nextBgTasks = { ...existingBgTasks };
-  if (args.perTaskEntry) {
-    const { toolCallId, startedAt, completedAt, taskId, suspendedAt } = args.perTaskEntry;
-    const prev = existingBgTasks[toolCallId] ?? { taskId };
-    nextBgTasks[toolCallId] = {
-      ...prev,
-      taskId,
-      ...startedAt !== void 0 ? { startedAt } : {},
-      ...completedAt !== void 0 ? { completedAt } : {},
-      ...suspendedAt !== void 0 ? { suspendedAt } : {}
-    };
-  }
-  return {
-    ...existingAny,
-    ...otherMetadata ?? {},
-    mode,
-    ...args.resetRunningCount ? { runningBackgroundTasksCount: void 0 } : {},
-    backgroundTasks: nextBgTasks
-  };
 };
-
-// src/lib/ai-sdk/utils/toAssistantUIMessage.ts
-var 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") {
-      const type = part.mediaType.includes("image/") ? "image" : "file";
-      if (type === "file") {
-        return {
-          type,
-          mimeType: part.mediaType,
-          data: part.url,
-          // Use URL as data source
-          metadata: message.metadata
-        };
-      }
-      if (type === "image") {
-        return {
-          type,
-          image: part.url,
-          metadata: message.metadata
-        };
-      }
-    }
-    if (part.type === "dynamic-tool") {
-      const baseToolCall = {
-        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 toolName2 = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.substring(5);
-      const { suspendedToolRunId, ...cleanInput } = "input" in part ? part.input : {};
-      const baseToolCall = {
-        type: "tool-call",
-        toolCallId: "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "",
-        toolName: toolName2,
-        argsText: JSON.stringify(cleanInput ?? {}),
-        args: cleanInput ?? {},
-        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;
-    }
-    const toolName = "toolName" in part && typeof part.toolName === "string" ? part.toolName : part.type.startsWith("tool-") ? part.type.substring(5) : "";
-    const requireApprovalMetadata = extendedMessage.metadata?.requireApprovalMetadata;
-    const suspendedTools = extendedMessage.metadata?.suspendedTools;
-    const partToolCallId = "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : void 0;
-    const suspensionData = toolName ? requireApprovalMetadata?.[toolName] ?? suspendedTools?.[toolName] : void 0;
-    if (suspensionData) {
-      const { suspendedToolRunId, ...cleanInput } = "input" in part ? part.input : {};
-      return {
-        type: "tool-call",
-        toolCallId: partToolCallId,
-        toolName,
-        argsText: JSON.stringify(cleanInput ?? {}),
-        args: cleanInput,
-        metadata: extendedMessage.metadata
-      };
-    }
-    if (part.type.startsWith("data-")) {
-      return {
-        type: "data",
-        name: part.type.substring(5),
-        // Extract name from 'data-{name}'
-        data: part.data,
-        metadata: message.metadata
-      };
-    }
-    return {
-      type: "text",
-      text: "",
-      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" };
+var handleRoutingAgentDelta = (chunk, conversation, metadata) => {
+  const delta = chunk.payload?.text ?? "";
+  if (!delta) return conversation;
+  const lastMessage = lastAssistant(conversation);
+  const mergeRoutingMetadata = (existing) => {
+    const buffered = (existing.routingDecisionBuffer ?? "") + delta;
+    const next = { ...cloneMetadata(existing), mode: "network" };
+    const parsed = tryParseRoutingDecision(buffered);
+    if (parsed) {
+      next.routingDecision = parsed;
+      delete next.routingDecisionBuffer;
+      delete next.routingDecisionText;
     } else {
-      status = { type: "complete", reason: "stop" };
+      next.routingDecisionBuffer = buffered;
+      next.routingDecisionText = buffered;
     }
-  }
-  const threadMessage = {
-    role: message.role,
-    content,
-    id: message.id,
-    createdAt: extendedMessage.createdAt,
-    status,
-    attachments: extendedMessage.experimental_attachments
+    return next;
   };
-  return threadMessage;
-};
-
-// src/lib/ai-sdk/memory/resolveInitialMessages.ts
-var resolveInitialMessages = (messages) => {
-  const messagesLength = messages.length;
-  return messages.map((message, index) => {
-    const networkPart = message.parts.find(
-      (part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string" && part.text.includes('"isNetwork":true')
+  if (!lastMessage) {
+    const seed = mergeRoutingMetadata({});
+    return appendAssistantMessage(
+      conversation,
+      `routing-agent-${chunk.payload?.runId ?? "unknown"}-${Date.now()}`,
+      [],
+      { ...networkMode(metadata), ...seed }
     );
-    if (networkPart && networkPart.type === "text") {
-      try {
-        const json = JSON.parse(networkPart.text);
-        if (json.isNetwork === true) {
-          const selectionReason = json.selectionReason || "";
-          const primitiveType = json.primitiveType || "";
-          const primitiveId = json.primitiveId || "";
-          const finalResult = json.finalResult;
-          const messages2 = finalResult?.messages || [];
-          const childMessages = [];
-          const toolResultMap = /* @__PURE__ */ new Map();
-          for (const msg of messages2) {
-            if (Array.isArray(msg.content)) {
-              for (const part of msg.content) {
-                if (typeof part === "object" && part.type === "tool-result") {
-                  toolResultMap.set(part.toolCallId, part);
-                }
-              }
-            }
-          }
-          for (const msg of messages2) {
-            if (msg.type === "tool-call" && Array.isArray(msg.content)) {
-              for (const part of msg.content) {
-                if (typeof part === "object" && part.type === "tool-call") {
-                  const toolCallContent = part;
-                  const toolResult = toolResultMap.get(toolCallContent.toolCallId);
-                  const isWorkflow = Boolean(toolResult?.result?.result?.steps);
-                  childMessages.push({
-                    type: "tool",
-                    toolCallId: toolCallContent.toolCallId,
-                    toolName: toolCallContent.toolName,
-                    args: toolCallContent.args,
-                    toolOutput: isWorkflow ? toolResult?.result?.result : toolResult?.result
-                  });
-                }
-              }
-            }
-          }
-          if (finalResult && finalResult.text) {
-            childMessages.push({
-              type: "text",
-              content: finalResult.text
-            });
-          }
-          const result = primitiveType === "tool" ? finalResult?.result : {
-            childMessages,
-            result: finalResult?.text || ""
-          };
-          const nextMessage = {
-            role: "assistant",
-            parts: [
-              {
-                type: "dynamic-tool",
-                toolCallId: primitiveId,
-                toolName: primitiveId,
-                state: "output-available",
-                input: json.input,
-                output: result
-              }
-            ],
-            id: message.id,
-            metadata: {
-              ...message.metadata,
-              mode: "network",
-              selectionReason,
-              agentInput: json.input,
-              hasMoreMessages: index < messagesLength - 1,
-              from: primitiveType === "agent" ? "AGENT" : primitiveType === "tool" ? "TOOL" : "WORKFLOW"
-            }
-          };
-          return nextMessage;
-        }
-      } catch {
-        return message;
-      }
-    }
-    const extendedMessage = message;
-    const pendingToolApprovals = extendedMessage.metadata?.pendingToolApprovals;
-    if (pendingToolApprovals && typeof pendingToolApprovals === "object") {
-      const stillPending = Object.fromEntries(
-        Object.entries(pendingToolApprovals).filter(([_, approval]) => {
-          if (!approval || typeof approval !== "object" || !("toolCallId" in approval)) {
-            return false;
-          }
-          const toolCallId = approval.toolCallId;
-          return !message.parts.some(
-            (part) => part.toolCallId === toolCallId && (part.state === "output-available" || part.output != null)
-          );
-        })
-      );
-      return {
-        ...message,
-        metadata: {
-          ...message.metadata,
-          mode: "stream",
-          ...Object.keys(stillPending).length > 0 ? { requireApprovalMetadata: stillPending } : {}
-        }
-      };
-    }
-    const suspendedTools = extendedMessage.metadata?.suspendedTools;
-    if (suspendedTools && typeof suspendedTools === "object") {
-      return {
-        ...message,
-        metadata: {
-          ...message.metadata,
-          mode: "stream",
-          suspendedTools
-        }
-      };
-    }
-    return message;
-  })?.filter((message) => {
-    const completionModes = ["generate", "stream", "network"];
-    if (message.role === "assistant" && completionModes.includes(message?.metadata?.mode)) {
-      const meta = message.metadata;
-      if (meta?.isTaskCompleteResult?.suppressFeedback || meta?.completionResult?.suppressFeedback) {
-        return false;
-      }
-      return true;
-    }
-    return true;
-  });
-};
-var resolveToChildMessages = (messages) => {
-  const assistantMessage = messages.find((message) => message.role === "assistant");
-  if (!assistantMessage) return [];
-  const parts = assistantMessage.parts;
-  let childMessages = [];
-  for (const part of parts) {
-    const toolPart = part;
-    if (part.type.startsWith("tool-")) {
-      const toolName = part.type.substring("tool-".length);
-      const isWorkflow = toolName.startsWith("workflow-");
-      childMessages.push({
-        type: "tool",
-        toolCallId: toolPart.toolCallId,
-        toolName,
-        args: toolPart.input,
-        toolOutput: isWorkflow ? { ...toolPart.output?.result, runId: toolPart.output?.runId } : toolPart.output
-      });
-    }
-    if (part.type === "text") {
-      childMessages.push({
-        type: "text",
-        content: toolPart.text
-      });
-    }
   }
-  return childMessages;
+  return replaceLast(conversation, withMetadata(lastMessage, mergeRoutingMetadata(lastMessage.content.metadata ?? {})));
 };
-
-// src/lib/ai-sdk/transformers/AISdkNetworkTransformer.ts
-var AISdkNetworkTransformer = class {
-  transform({ chunk, conversation, metadata }) {
-    const newConversation = [...conversation];
-    if (chunk.type === "routing-agent-text-delta") {
-      return this.handleRoutingAgentConversation(chunk, newConversation);
-    }
-    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-validation-end") {
-      if (chunk.payload.suppressFeedback) return newConversation;
-      const feedback = formatCompletionFeedback(
-        {
-          complete: chunk.payload.passed,
-          scorers: chunk.payload.results,
-          totalDuration: chunk.payload.duration,
-          timedOut: chunk.payload.timedOut},
-        chunk.payload.maxIterationReached
-      );
-      const newMessage = {
-        id: `network-validation-end-${chunk.payload.runId}-${Date.now()}`,
-        role: "assistant",
-        parts: [
-          {
-            type: "text",
-            text: feedback
-          }
-        ],
-        metadata: {
-          ...metadata,
-          mode: "network",
-          completionResult: {
-            passed: chunk.payload.passed
-          }
-        }
+var handleAgentNetworkChunk = (chunk, conversation, metadata) => {
+  if (chunk.type === "agent-execution-start") {
+    const primitiveId = chunk.payload?.args?.primitiveId;
+    const runId = chunk.payload.runId;
+    if (!primitiveId || !runId) return conversation;
+    const toolPart = {
+      type: "dynamic-tool",
+      toolName: primitiveId,
+      toolCallId: runId,
+      state: "input-available",
+      input: chunk.payload.args
+    };
+    return appendAssistantMessage(conversation, `agent-execution-start-${runId}-${Date.now()}`, [toolPart], {
+      ...networkMode(metadata),
+      selectionReason: chunk.payload?.args?.selectionReason || "",
+      agentInput: chunk.payload?.args?.task,
+      from: "AGENT"
+    });
+  }
+  if (chunk.type === "agent-execution-end") {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const parts = [...lastMessage.content.parts];
+    const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+    if (toolPartIndex !== -1) {
+      const toolPart = parts[toolPartIndex];
+      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, newMessage];
-    }
-    if (chunk.type === "network-execution-event-step-finish") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const agentChunk = chunk.payload;
-      const parts = [...lastMessage.parts];
-      const textPartIndex = parts.findIndex((part) => part.type === "text");
-      if (textPartIndex === -1) {
-        parts.push({
-          type: "text",
-          text: agentChunk.result,
-          state: "done"
-        });
-        return [
-          ...newConversation.slice(0, -1),
-          {
-            ...lastMessage,
-            parts
-          }
-        ];
-      }
-      const textPart = parts[textPartIndex];
-      if (textPart.type === "text") {
-        parts[textPartIndex] = {
-          ...textPart,
-          state: "done"
-        };
-        return [
-          ...newConversation.slice(0, -1),
-          {
-            ...lastMessage,
-            parts
-          }
-        ];
-      }
-      return newConversation;
     }
-    return newConversation;
+    return replaceLast(conversation, withParts(lastMessage, parts));
   }
-  handleRoutingAgentConversation = (chunk, newConversation) => {
-    const lastMessage = newConversation[newConversation.length - 1];
-    if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
+  if (chunk.type.startsWith("agent-execution-event-")) {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
     const agentChunk = chunk.payload;
-    const parts = [...lastMessage.parts];
-    const textPartIndex = parts.findIndex((part) => part.type === "text");
-    if (textPartIndex === -1) {
-      parts.push({
-        type: "text",
-        text: agentChunk.text,
-        state: "streaming"
-      });
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    const textPart = parts[textPartIndex];
-    if (textPart.type === "text") {
-      parts[textPartIndex] = {
-        ...textPart,
-        text: textPart.text + agentChunk.text,
-        state: "streaming"
-      };
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          parts
-        }
-      ];
-    }
-    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"
-        }
+    const parts = [...lastMessage.content.parts];
+    const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+    if (toolPartIndex === -1) return conversation;
+    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 }
       };
-      return [...newConversation, newMessage];
-    }
-    if (chunk.type === "agent-execution-approval") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.requireApprovalMetadata : {};
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            ...lastMessage.metadata,
-            mode: "network",
-            requireApprovalMetadata: {
-              ...lastRequireApprovalMetadata,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                runId: chunk.payload.runId
-              }
-            }
-          }
-        }
-      ];
-    }
-    if (chunk.type === "agent-execution-suspended") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            ...lastMessage.metadata,
-            mode: "network",
-            suspendedTools: {
-              ...lastSuspendedTools,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                suspendPayload: chunk.payload.suspendPayload,
-                runId: chunk.payload.runId
-              }
+    } 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
             }
-          }
+          ]
         }
-      ];
-    }
-    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;
+      };
+    } 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] = {
-            type: "dynamic-tool",
-            toolName: toolPart.toolName,
-            toolCallId: toolPart.toolCallId,
-            state: "output-available",
-            input: toolPart.input,
+            ...toolPart,
             output: {
-              ...currentOutput,
-              result: currentOutput?.result || chunk.payload?.result || ""
+              ...toolPart?.output,
+              childMessages: [...childMessages.slice(0, -1), { ...currentMessage, toolOutput: updatedWorkflowState }]
             }
           };
         }
       }
-      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 || [];
+    } 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,
+              ...childMessages.slice(0, -1),
               {
-                type: "tool",
-                toolCallId: agentChunk.payload.toolCallId,
-                toolName: agentChunk.payload.toolName,
-                args: agentChunk.payload.args
+                ...childMessages[lastToolIndex],
+                toolOutput: isWorkflow ? agentChunk.payload.result.result : agentChunk.payload.result
               }
             ]
           }
         };
-      } 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
-                  }
-                ]
-              }
-            };
+      }
+    }
+    return replaceLast(conversation, withParts(lastMessage, parts));
+  }
+  return conversation;
+};
+var handleWorkflowNetworkChunk = (chunk, conversation, metadata) => {
+  if (chunk.type === "workflow-execution-start") {
+    const primitiveId = chunk.payload?.args?.primitiveId;
+    const runId = chunk.payload.runId;
+    if (!primitiveId || !runId) return conversation;
+    let agentInput;
+    try {
+      agentInput = JSON.parse(chunk.payload?.args?.prompt);
+    } catch {
+      agentInput = chunk.payload?.args?.prompt;
+    }
+    const toolPart = {
+      type: "dynamic-tool",
+      toolName: primitiveId,
+      toolCallId: runId,
+      state: "input-available",
+      input: chunk.payload.args
+    };
+    return appendAssistantMessage(conversation, `workflow-start-${runId}-${Date.now()}`, [toolPart], {
+      ...networkMode(metadata),
+      selectionReason: chunk.payload?.args?.selectionReason || "",
+      from: "WORKFLOW",
+      agentInput
+    });
+  }
+  if (chunk.type === "workflow-execution-suspended") {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const existing = lastMessage.content.metadata?.suspendedTools ?? {};
+    return replaceLast(
+      conversation,
+      withMetadata(lastMessage, {
+        ...cloneMetadata(lastMessage.content.metadata),
+        mode: "network",
+        suspendedTools: {
+          ...existing,
+          [chunk.payload.toolName]: {
+            toolCallId: chunk.payload.toolCallId,
+            toolName: chunk.payload.toolName,
+            args: chunk.payload.args,
+            suspendPayload: chunk.payload.suspendPayload,
+            runId: chunk.payload.runId
           }
         }
-      } 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),
+      })
+    );
+  }
+  if (chunk.type.startsWith("workflow-execution-event-")) {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const parts = [...lastMessage.content.parts];
+    const toolPartIndex = findPartIndex(parts, (part) => isDynamicToolPart(part));
+    if (toolPartIndex === -1) return conversation;
+    const toolPart = parts[toolPartIndex];
+    const existingWorkflowState = toolPart.output || {};
+    const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload);
+    parts[toolPartIndex] = { ...toolPart, output: updatedWorkflowState };
+    return replaceLast(conversation, withParts(lastMessage, parts));
+  }
+  return conversation;
+};
+var handleToolNetworkChunk = (chunk, conversation, metadata) => {
+  if (chunk.type === "tool-execution-start") {
+    const argsData = chunk.payload.args;
+    const nestedArgs = argsData.args || {};
+    const lastMessage = lastAssistant(conversation);
+    const toolPart = {
+      type: "dynamic-tool",
+      toolName: argsData.toolName || "unknown",
+      toolCallId: argsData.toolCallId || "unknown",
+      state: "input-available",
+      input: nestedArgs
+    };
+    if (!lastMessage) {
+      return appendAssistantMessage(
+        conversation,
+        `tool-start-${chunk.payload.runId}-${Date.now()}`,
+        [toolPart],
         {
-          ...lastMessage,
-          parts
+          ...networkMode(metadata),
+          selectionReason: metadata.mode === "network" ? metadata.selectionReason || argsData.selectionReason : "",
+          agentInput: nestedArgs
         }
-      ];
+      );
     }
-    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 {
-        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
+    const parts = [...lastMessage.content.parts, toolPart];
+    return replaceLast(conversation, withParts(lastMessage, parts));
+  }
+  if (chunk.type === "tool-execution-approval") {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const existing = lastMessage.content.metadata?.requireApprovalMetadata ?? {};
+    return replaceLast(
+      conversation,
+      withMetadata(lastMessage, {
+        ...cloneMetadata(lastMessage.content.metadata),
+        mode: "network",
+        requireApprovalMetadata: {
+          ...existing,
+          [chunk.payload.toolName]: {
+            toolCallId: chunk.payload.toolCallId,
+            toolName: chunk.payload.toolName,
+            args: chunk.payload.args,
+            runId: chunk.payload.runId
           }
-        ],
-        metadata: {
-          ...metadata,
-          selectionReason: chunk.payload?.args?.selectionReason || "",
-          from: "WORKFLOW",
-          mode: "network",
-          agentInput
         }
-      };
-      return [...newConversation, newMessage];
-    }
-    if (chunk.type === "workflow-execution-suspended") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            ...lastMessage.metadata,
-            mode: "network",
-            suspendedTools: {
-              ...lastSuspendedTools,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                suspendPayload: chunk.payload.suspendPayload,
-                runId: chunk.payload.runId
-              }
-            }
+      })
+    );
+  }
+  if (chunk.type === "tool-execution-suspended") {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const existing = lastMessage.content.metadata?.suspendedTools ?? {};
+    return replaceLast(
+      conversation,
+      withMetadata(lastMessage, {
+        ...cloneMetadata(lastMessage.content.metadata),
+        mode: "network",
+        suspendedTools: {
+          ...existing,
+          [chunk.payload.toolName]: {
+            toolCallId: chunk.payload.toolCallId,
+            toolName: chunk.payload.toolName,
+            args: chunk.payload.args,
+            suspendPayload: chunk.payload.suspendPayload,
+            runId: chunk.payload.runId
           }
         }
-      ];
-    }
-    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;
+      })
+    );
+  }
+  if (chunk.type === "tool-execution-end") {
+    const lastMessage = lastAssistant(conversation);
+    if (!lastMessage) return conversation;
+    const parts = [...lastMessage.content.parts];
+    const toolPartIndex = findPartIndex(
+      parts,
+      (part) => isDynamicToolPart(part) && part.toolCallId === chunk.payload.toolCallId
+    );
+    if (toolPartIndex !== -1) {
       const toolPart = parts[toolPartIndex];
-      if (toolPart.type !== "dynamic-tool") return newConversation;
-      const existingWorkflowState = toolPart.output || {};
-      const updatedWorkflowState = mapWorkflowStreamChunkToWatchResult(existingWorkflowState, chunk.payload);
+      const currentOutput = toolPart.output;
       parts[toolPartIndex] = {
-        ...toolPart,
-        output: updatedWorkflowState
+        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;
-  };
-  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];
+    return replaceLast(conversation, withParts(lastMessage, parts));
+  }
+  return conversation;
+};
+var accumulateNetworkChunk = ({
+  chunk,
+  conversation,
+  metadata
+}) => {
+  const newConversation = [...conversation];
+  if (chunk.type === "routing-agent-text-delta") {
+    return handleRoutingAgentDelta(chunk, newConversation, metadata);
+  }
+  if (chunk.type.startsWith("agent-execution-")) {
+    return handleAgentNetworkChunk(chunk, newConversation, metadata);
+  }
+  if (chunk.type.startsWith("workflow-execution-")) {
+    return handleWorkflowNetworkChunk(chunk, newConversation, metadata);
+  }
+  if (chunk.type.startsWith("tool-execution-")) {
+    return handleToolNetworkChunk(chunk, newConversation, metadata);
+  }
+  if (chunk.type === "network-validation-end") {
+    if (chunk.payload.suppressFeedback) return newConversation;
+    const feedback = formatCompletionFeedback(
+      {
+        complete: chunk.payload.passed,
+        scorers: chunk.payload.results,
+        totalDuration: chunk.payload.duration,
+        timedOut: chunk.payload.timedOut},
+      chunk.payload.maxIterationReached
+    );
+    const textPart = { type: "text", text: feedback };
+    return appendAssistantMessage(
+      newConversation,
+      `network-validation-end-${chunk.payload.runId}-${Date.now()}`,
+      [textPart],
+      {
+        ...networkMode(metadata),
+        completionResult: { passed: chunk.payload.passed }
       }
-      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-approval") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const lastRequireApprovalMetadata = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.requireApprovalMetadata : {};
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            ...lastMessage.metadata,
-            mode: "network",
-            requireApprovalMetadata: {
-              ...lastRequireApprovalMetadata,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                runId: chunk.payload.runId
-              }
-            }
-          }
-        }
-      ];
-    }
-    if (chunk.type === "tool-execution-suspended") {
-      const lastMessage = newConversation[newConversation.length - 1];
-      if (!lastMessage || lastMessage.role !== "assistant") return newConversation;
-      const lastSuspendedTools = lastMessage.metadata?.mode === "network" ? lastMessage.metadata?.suspendedTools : {};
-      return [
-        ...newConversation.slice(0, -1),
-        {
-          ...lastMessage,
-          metadata: {
-            ...lastMessage.metadata,
-            mode: "network",
-            suspendedTools: {
-              ...lastSuspendedTools,
-              [chunk.payload.toolName]: {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args,
-                suspendPayload: chunk.payload.suspendPayload,
-                runId: chunk.payload.runId
-              }
-            }
-          }
-        }
-      ];
+    );
+  }
+  if (chunk.type === "network-execution-event-step-finish") {
+    const lastMessage = lastAssistant(newConversation);
+    if (!lastMessage) return newConversation;
+    const agentChunk = chunk.payload;
+    const parts = [...lastMessage.content.parts];
+    const textPartIndex = findPartIndex(parts, (part) => part.type === "text");
+    if (textPartIndex === -1) {
+      parts.push({ type: "text", text: agentChunk.result, state: "done" });
+      return replaceLast(newConversation, withParts(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
-        }
-      ];
+    const textPart = parts[textPartIndex];
+    if (textPart.type === "text") {
+      parts[textPartIndex] = {
+        ...textPart,
+        state: "done"
+      };
+      return replaceLast(newConversation, withParts(lastMessage, parts));
     }
     return newConversation;
-  };
+  }
+  return newConversation;
 };
 
-// src/lib/ai-sdk/utils/fromCoreUserMessageToUIMessage.tsx
-var fromCoreUserMessageToUIMessage = (coreUserMessage) => {
+// src/lib/mastra-db/fromCoreUserMessage.ts
+var fromCoreUserMessageToMastraDBMessage = (coreUserMessage) => {
   const id = `user-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-  const parts = typeof coreUserMessage.content === "string" ? [
-    {
-      type: "text",
-      text: coreUserMessage.content
-    }
-  ] : coreUserMessage.content.map((part) => {
+  const parts = typeof coreUserMessage.content === "string" ? [{ type: "text", text: coreUserMessage.content }] : coreUserMessage.content.map((part) => {
     switch (part.type) {
       case "text": {
-        return {
-          type: "text",
-          text: part.text
-        };
+        return { type: "text", text: part.text };
       }
       case "image": {
         const url = typeof part.image === "string" ? part.image : part.image instanceof URL ? part.image.toString() : "";
@@ -1984,23 +1665,35 @@ var fromCoreUserMessageToUIMessage = (coreUserMessage) => {
   return {
     id,
     role: "user",
-    parts
+    createdAt: /* @__PURE__ */ new Date(),
+    content: {
+      format: 2,
+      parts
+    }
   };
 };
 
 // src/agent/extractRunIdFromMessages.ts
+var isRecord = (value) => value !== null && typeof value === "object";
+var runIdMetadataKeys = ["pendingToolApprovals", "requireApprovalMetadata", "suspendedTools"];
+var isRunIdMetadataSource = (value) => isRecord(value) && Object.values(value).every((entry) => isRecord(entry));
+var getRunIdMetadataSources = (metadata) => {
+  if (!isRecord(metadata)) return [];
+  const sources = [];
+  for (const key of runIdMetadataKeys) {
+    const source = metadata[key];
+    if (isRunIdMetadataSource(source)) {
+      sources.push(source);
+    }
+  }
+  return sources;
+};
 var extractRunIdFromMessages = (messages) => {
   for (const message of messages) {
-    const metadataSources = [
-      message.metadata?.pendingToolApprovals,
-      message.metadata?.requireApprovalMetadata,
-      message.metadata?.suspendedTools
-    ];
-    for (const source of metadataSources) {
-      if (!source || typeof source !== "object") continue;
-      for (const suspensionData of Object.values(source)) {
-        if (suspensionData && typeof suspensionData === "object" && typeof suspensionData.runId === "string" && suspensionData.runId.length > 0) {
-          return suspensionData.runId;
+    for (const source of getRunIdMetadataSources(message.content?.metadata)) {
+      for (const entry of Object.values(source)) {
+        if (isRecord(entry) && typeof entry.runId === "string" && entry.runId.length > 0) {
+          return entry.runId;
         }
       }
     }
@@ -2025,11 +1718,12 @@ function convertSignalDataToBase64String(content) {
 var extractPendingToolApprovalIdsFromMessages = (messages) => {
   const pendingToolApprovalIds = /* @__PURE__ */ new Set();
   for (const message of messages) {
-    const metadata = message.metadata;
+    const metadata = message.content?.metadata;
+    if (!metadata) continue;
     const metadataSources = [
-      metadata?.pendingToolApprovals,
-      metadata?.requireApprovalMetadata,
-      metadata?.suspendedTools
+      metadata.pendingToolApprovals,
+      metadata.requireApprovalMetadata,
+      metadata.suspendedTools
     ];
     for (const source of metadataSources) {
       if (!source || typeof source !== "object") continue;
@@ -2043,14 +1737,68 @@ var extractPendingToolApprovalIdsFromMessages = (messages) => {
   }
   return pendingToolApprovalIds;
 };
+var toolCallHasOutput = (parts, toolCallId) => parts.some((part) => {
+  if (part.type !== "tool-invocation") return false;
+  const invocation = part.toolInvocation;
+  if (invocation.toolCallId !== toolCallId) return false;
+  return invocation.state === "result" || invocation.result != null;
+});
+var resolveInitialMessages = (messages) => messages.filter((message) => {
+  const metadata = message.content?.metadata;
+  if (metadata?.completionResult?.suppressFeedback || metadata?.isTaskCompleteResult?.suppressFeedback) {
+    return false;
+  }
+  return true;
+}).map((message) => {
+  const metadata = message.content?.metadata;
+  const pendingToolApprovals = metadata?.pendingToolApprovals;
+  if (!pendingToolApprovals || typeof pendingToolApprovals !== "object") {
+    return message;
+  }
+  const stillPending = Object.fromEntries(
+    Object.entries(pendingToolApprovals).filter(
+      ([, approval]) => approval && typeof approval === "object" && typeof approval.toolCallId === "string" && !toolCallHasOutput(message.content.parts, approval.toolCallId)
+    )
+  );
+  const { pendingToolApprovals: _omit, ...restMetadata } = metadata;
+  const hasStillPending = Object.keys(stillPending).length > 0;
+  return {
+    ...message,
+    content: {
+      ...message.content,
+      metadata: {
+        ...restMetadata,
+        mode: "stream",
+        ...hasStillPending ? { pendingToolApprovals: stillPending, requireApprovalMetadata: stillPending } : {}
+      }
+    }
+  };
+});
+var isObject = (value) => typeof value === "object" && value !== null;
+var getErrorName = (error) => isObject(error) && typeof error.name === "string" ? error.name : void 0;
+var isAbortError = (error) => getErrorName(error) === "AbortError";
 var isThreadSignalUnsupportedError = (error) => {
-  const candidate = error;
-  const status = candidate?.status;
+  if (!isObject(error)) return false;
+  const status = error.status;
   if (status === 404 || status === 405 || status === 501) {
     return true;
   }
-  return status === 400 && candidate?.message?.includes("No active agent run found for signal target");
+  return status === 400 && typeof error.message === "string" && error.message.includes("No active agent run found for signal target");
 };
+var isDataChunk2 = (chunk) => typeof chunk.type === "string" && chunk.type.startsWith("data-");
+var dbFromServerUiMessages = (uiMessages, metadata) => uiMessages.map((uiMsg) => {
+  const dbMsg = messageList.AIV5Adapter.fromUIMessage(uiMsg);
+  return {
+    ...dbMsg,
+    content: {
+      ...dbMsg.content,
+      metadata: {
+        ...dbMsg.content.metadata ?? {},
+        ...metadata
+      }
+    }
+  };
+});
 var useChat = ({
   agentId,
   resourceId,
@@ -2085,7 +1833,7 @@ var useChat = ({
   const baseClient = useMastraClient();
   const [isRunning, setIsRunning] = react.useState(false);
   react.useEffect(() => {
-    const formattedMessages = resolveInitialMessages(initialMessages || []);
+    const formattedMessages = resolveInitialMessages(initialMessages ?? []);
     setMessages(formattedMessages);
     pendingToolApprovalIdsRef.current = extractPendingToolApprovalIdsFromMessages(formattedMessages);
     setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
@@ -2157,8 +1905,8 @@ var useChat = ({
   }, []);
   const processStreamChunk = react.useCallback(
     async (chunk, onChunk) => {
-      setMessages((prev) => toUIMessage({ chunk, conversation: prev, metadata: { mode: "stream" } }));
-      if (chunk.type === "data-user-message" && "data" in chunk && typeof chunk.data?.id === "string") {
+      setMessages((prev) => accumulateChunk({ chunk, conversation: prev, metadata: { mode: "stream" } }));
+      if (chunk.type === "data-user-message" && isDataChunk2(chunk) && (chunk.data?.type === "user-message" || chunk.data?.type === "user") && typeof chunk.data?.id === "string") {
         onSignalEcho?.(chunk.data.id);
       }
       if (chunk.type === "start") {
@@ -2203,18 +1951,14 @@ var useChat = ({
       _threadSubscriptionPromiseRef.current = subscriptionAgent.subscribeToThread({ resourceId: resourceId2, threadId: threadId2 }).then((response) => {
         const subscription = response;
         if (_threadSubscriptionAbortRef.current !== subscriptionAbort) {
-          if (subscription.unsubscribe) {
-            subscription.unsubscribe();
-          } else {
-            subscriptionAbort.abort();
-          }
+          subscription.unsubscribe();
           return;
         }
         _threadSubscriptionRef.current = subscription;
         void subscription.processDataStream({
           onChunk: (chunk) => processStreamChunk(chunk)
         }).catch((error) => {
-          if (error.name !== "AbortError") {
+          if (!isAbortError(error)) {
             console.error("[useChat] Thread subscription failed", error);
             setIsRunning(false);
           }
@@ -2239,7 +1983,7 @@ var useChat = ({
           }
           return;
         }
-        if (error.name !== "AbortError") {
+        if (!isAbortError(error)) {
           console.error("[useChat] Thread subscription failed", error);
           setIsRunning(false);
         }
@@ -2259,7 +2003,7 @@ var useChat = ({
       return;
     }
     void ensureThreadSubscription({ threadId, resourceId: resourceId || agentId }).catch((error) => {
-      if (error.name !== "AbortError") {
+      if (!isAbortError(error)) {
         console.error("[useChat] Thread subscription failed", error);
       }
     });
@@ -2321,34 +2065,22 @@ var useChat = ({
     if (response.finishReason === "suspended" && response.suspendPayload) {
       const { toolCallId, toolName, args } = response.suspendPayload;
       if (response.response?.uiMessages) {
-        const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
-          ...message,
-          metadata: {
-            mode: "generate",
-            requireApprovalMetadata: {
-              [toolName]: {
-                toolCallId,
-                toolName,
-                args
-              }
-            }
+        const dbMessages = dbFromServerUiMessages(response.response.uiMessages, {
+          mode: "generate",
+          requireApprovalMetadata: {
+            [toolName]: { toolCallId, toolName, args }
           }
-        }));
-        setMessages((prev) => [...prev, ...mastraUIMessages]);
+        });
+        setMessages((prev) => [...prev, ...dbMessages]);
       }
       setIsRunning(false);
       return;
     }
     setIsRunning(false);
     if (response && "uiMessages" in response.response && response.response.uiMessages) {
-      void onFinish?.(response.response.uiMessages);
-      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
-        ...message,
-        metadata: {
-          mode: "generate"
-        }
-      }));
-      setMessages((prev) => [...prev, ...mastraUIMessages]);
+      const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+      void onFinish?.(dbMessages);
+      setMessages((prev) => [...prev, ...dbMessages]);
     }
   };
   const stream = async ({
@@ -2450,14 +2182,27 @@ var useChat = ({
       return;
     }
     const resolvedSignalId = signalId ?? uuid.v4();
-    onSignalSent?.(resolvedSignalId, getSignalPreview(coreUserMessages));
+    const messageContents = getSignalContents(coreUserMessages);
+    const streamOptions = {
+      maxSteps,
+      modelSettings: {
+        frequencyPenalty,
+        presencePenalty,
+        maxRetries,
+        maxOutputTokens: maxTokens,
+        temperature,
+        topK,
+        topP
+      },
+      instructions,
+      requestContext: resolvedRequestContext,
+      providerOptions,
+      requireToolApproval,
+      tracingOptions
+    };
     try {
-      await agent.sendSignal({
-        signal: {
-          id: resolvedSignalId,
-          type: "user-message",
-          contents: getSignalContents(coreUserMessages)
-        },
+      const result = await agent.sendMessage({
+        message: messageContents,
         resourceId: resourceId || agentId,
         threadId: threadId2,
         ifIdle: {
@@ -2468,16 +2213,36 @@ var useChat = ({
           }
         }
       });
+      const echoedSignalId = result.signal && typeof result.signal === "object" && "id" in result.signal && typeof result.signal.id === "string" ? result.signal.id : resolvedSignalId;
+      onSignalSent?.(echoedSignalId, getSignalPreview(coreUserMessages));
       if (pendingToolApprovalIdsRef.current.size > 0) {
         setIsRunning(false);
       }
     } catch (error) {
-      onSignalEcho?.(resolvedSignalId);
       if (isThreadSignalUnsupportedError(error)) {
-        markThreadSignalsUnsupported();
-        setMessages((prev) => [...prev, ...coreUserMessages.map(fromCoreUserMessageToUIMessage)]);
-        await streamWithLegacyRoute();
-        return;
+        onSignalSent?.(resolvedSignalId, getSignalPreview(coreUserMessages));
+        try {
+          await agent.sendSignal({
+            signal: {
+              id: resolvedSignalId,
+              type: "user-message",
+              contents: messageContents
+            },
+            resourceId: resourceId || agentId,
+            threadId: threadId2,
+            ifIdle: { streamOptions }
+          });
+          return;
+        } catch (signalError) {
+          onSignalEcho?.(resolvedSignalId);
+          if (isThreadSignalUnsupportedError(signalError)) {
+            markThreadSignalsUnsupported();
+            setMessages((prev) => [...prev, ...coreUserMessages.map(fromCoreUserMessageToMastraDBMessage)]);
+            await streamWithLegacyRoute();
+            return;
+          }
+          throw signalError;
+        }
       }
       throw error;
     }
@@ -2522,13 +2287,13 @@ var useChat = ({
     });
     _onNetworkChunk.current = onNetworkChunk;
     _networkRunId.current = runId;
-    const transformer = new AISdkNetworkTransformer();
     await response.processDataStream({
       onChunk: async (chunk) => {
-        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        setMessages((prev) => accumulateNetworkChunk({ chunk, conversation: prev, metadata: { mode: "network" } }));
         void onNetworkChunk?.(chunk);
       }
     });
+    setMessages((prev) => finishStreamingAssistantMessage(prev));
     setIsRunning(false);
   };
   const handleCancelRun = () => {
@@ -2650,13 +2415,8 @@ var useChat = ({
       requestContext: _requestContext.current
     });
     if (response && "uiMessages" in response.response && response.response.uiMessages) {
-      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
-        ...message,
-        metadata: {
-          mode: "generate"
-        }
-      }));
-      setMessages((prev) => [...prev, ...mastraUIMessages]);
+      const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+      setMessages((prev) => [...prev, ...dbMessages]);
     }
     setIsRunning(false);
   };
@@ -2675,13 +2435,8 @@ var useChat = ({
       requestContext: _requestContext.current
     });
     if (response && "uiMessages" in response.response && response.response.uiMessages) {
-      const mastraUIMessages = (response.response.uiMessages || []).map((message) => ({
-        ...message,
-        metadata: {
-          mode: "generate"
-        }
-      }));
-      setMessages((prev) => [...prev, ...mastraUIMessages]);
+      const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+      setMessages((prev) => [...prev, ...dbMessages]);
     }
     setIsRunning(false);
   };
@@ -2702,13 +2457,13 @@ var useChat = ({
       runId: networkRunId,
       requestContext: _requestContext.current
     });
-    const transformer = new AISdkNetworkTransformer();
     await response.processDataStream({
       onChunk: async (chunk) => {
-        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        setMessages((prev) => accumulateNetworkChunk({ chunk, conversation: prev, metadata: { mode: "network" } }));
         void onNetworkChunk?.(chunk);
       }
     });
+    setMessages((prev) => finishStreamingAssistantMessage(prev));
     setIsRunning(false);
   };
   const declineNetworkToolCall = async (toolName, runId) => {
@@ -2728,13 +2483,13 @@ var useChat = ({
       runId: networkRunId,
       requestContext: _requestContext.current
     });
-    const transformer = new AISdkNetworkTransformer();
     await response.processDataStream({
       onChunk: async (chunk) => {
-        setMessages((prev) => transformer.transform({ chunk, conversation: prev, metadata: { mode: "network" } }));
+        setMessages((prev) => accumulateNetworkChunk({ chunk, conversation: prev, metadata: { mode: "network" } }));
         void onNetworkChunk?.(chunk);
       }
     });
+    setMessages((prev) => finishStreamingAssistantMessage(prev));
     setIsRunning(false);
   };
   const sendMessage = async ({ mode = "stream", ...args }) => {
@@ -2743,10 +2498,10 @@ var useChat = ({
     if (args.coreUserMessages) {
       coreUserMessages.push(...args.coreUserMessages);
     }
-    const uiMessages = coreUserMessages.map(fromCoreUserMessageToUIMessage);
-    const signalId = mode === "stream" && args.threadId && !_threadSignalsUnsupportedRef.current && !threadSignalsDisabled ? uiMessages[0]?.id : void 0;
+    const dbUserMessages = coreUserMessages.map(fromCoreUserMessageToMastraDBMessage);
+    const signalId = mode === "stream" && args.threadId && !_threadSignalsUnsupportedRef.current && !threadSignalsDisabled ? dbUserMessages[0]?.id : void 0;
     if (!signalId) {
-      setMessages((s) => [...s, ...uiMessages]);
+      setMessages((s) => [...s, ...dbUserMessages]);
     }
     if (mode === "generate") {
       await generate({ ...args, coreUserMessages });
@@ -3075,6 +2830,117 @@ var MessageStreamingClass = "mastra:inline-block mastra:w-[2px] mastra:h-[1em] m
 var MessageStreaming = ({ className, ...props }) => {
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className: className || MessageStreamingClass, ...props });
 };
+var isDynamicToolPart2 = (part) => (
+  // `tool-invocation` is the v4 typed discriminant and must NOT be treated as a
+  // v5 `tool-${string}` streaming part, even though it shares the `tool-` prefix.
+  part.type === "dynamic-tool" || part.type.startsWith("tool-") && part.type !== "tool-invocation"
+);
+var isDataPart = (part) => part.type.startsWith("data-");
+var sourceToSourceUrl = (part) => ({
+  type: "source-url",
+  sourceId: part.source.id,
+  url: part.source.url,
+  title: part.source.title,
+  providerMetadata: part.providerMetadata
+});
+var getPartKey = (part, index) => {
+  if (isDynamicToolPart2(part)) {
+    return part.toolCallId ?? `${part.type}-${index}`;
+  }
+  switch (part.type) {
+    case "text":
+      return part.textId ?? `text-${index}`;
+    case "reasoning":
+      return part.reasoningId ?? `reasoning-${index}`;
+    case "tool-invocation":
+      return part.toolInvocation.toolCallId ?? `tool-invocation-${index}`;
+    case "source-url":
+      return part.sourceId || `source-url-${index}`;
+    case "source":
+      return part.source.id ?? `source-${index}`;
+  }
+  const id = part.id;
+  return id ?? `${part.type}-${index}`;
+};
+var renderPart = (part, renderers, fallback) => {
+  if (isDynamicToolPart2(part)) {
+    return renderers.DynamicTool?.(part) ?? fallback?.(part) ?? null;
+  }
+  if (isDataPart(part)) {
+    return renderers.Data?.(part) ?? fallback?.(part) ?? null;
+  }
+  switch (part.type) {
+    case "text":
+      return renderers.Text?.(part) ?? fallback?.(part) ?? null;
+    case "reasoning":
+      return renderers.Reasoning?.(part) ?? fallback?.(part) ?? null;
+    case "file":
+      return renderers.File?.(part) ?? fallback?.(part) ?? null;
+    case "step-start":
+      return renderers.StepStart?.(part) ?? fallback?.(part) ?? null;
+    case "tool-invocation":
+      return renderers.ToolInvocation?.(part) ?? fallback?.(part) ?? null;
+    case "source":
+      return renderers.SourceUrl?.(sourceToSourceUrl(part)) ?? fallback?.(part) ?? null;
+    case "source-url":
+      return renderers.SourceUrl?.(part) ?? fallback?.(part) ?? null;
+    case "source-document":
+      return renderers.SourceDocument?.(part) ?? fallback?.(part) ?? null;
+    default: {
+      return fallback?.(part) ?? null;
+    }
+  }
+};
+var PartRenderer = react.memo(({ part, renderers, fallback }) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderPart(part, renderers, fallback) }));
+PartRenderer.displayName = "PartRenderer";
+var joinText = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+var resolveTaskVerdict = (metadata) => {
+  const verdict = metadata?.completionResult ?? metadata?.isTaskCompleteResult;
+  if (!verdict) return void 0;
+  return { passed: !!verdict.passed, suppressFeedback: verdict.suppressFeedback };
+};
+var roleRendererFor = (role, roles) => {
+  switch (role) {
+    case "user":
+      return roles?.User;
+    case "assistant":
+      return roles?.Assistant;
+    case "system":
+      return roles?.System;
+    case "signal":
+      return roles?.Signal;
+    default:
+      return void 0;
+  }
+};
+var MessageFactoryComponent = ({ message, roles, status, fallback, ...renderers }) => {
+  const parts = message.content.parts ?? [];
+  const metadata = message.content.metadata;
+  let content;
+  if (metadata?.status === "tripwire" && status?.Tripwire) {
+    content = status.Tripwire({ text: joinText(parts), tripwire: metadata.tripwire, message });
+  } else if (metadata?.status === "warning" && status?.Warning) {
+    content = status.Warning({ text: joinText(parts), message });
+  } else if (metadata?.status === "error" && status?.Error) {
+    content = status.Error({ text: joinText(parts), message });
+  } else {
+    content = /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: parts.map((part, index) => /* @__PURE__ */ jsxRuntime.jsx(PartRenderer, { part, renderers, fallback }, getPartKey(part, index))) });
+    const verdict = resolveTaskVerdict(metadata);
+    if (verdict && status?.Task) {
+      content = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        content,
+        status.Task({ ...verdict, text: joinText(parts), message })
+      ] });
+    }
+  }
+  const RoleWrapper = roleRendererFor(message.role, roles);
+  if (RoleWrapper) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: RoleWrapper({ message, children: content }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: content });
+};
+var MessageFactory = react.memo(MessageFactoryComponent);
+MessageFactory.displayName = "MessageFactory";
 function useMutation(mutationFn) {
   const [isPending, setIsPending] = react.useState(false);
   const [isSuccess, setIsSuccess] = react.useState(false);
@@ -3511,6 +3377,7 @@ exports.MessageActionsClass = MessageActionsClass;
 exports.MessageClass = MessageClass;
 exports.MessageContent = MessageContent;
 exports.MessageContentClass = MessageContentClass;
+exports.MessageFactory = MessageFactory;
 exports.MessageList = MessageList;
 exports.MessageListClass = MessageListClass;
 exports.MessageStreaming = MessageStreaming;
@@ -3539,12 +3406,11 @@ exports.TooltipContent = TooltipContent;
 exports.TooltipContentClass = TooltipContentClass;
 exports.TooltipTrigger = TooltipTrigger;
 exports.WorkflowIcon = WorkflowIcon;
+exports.accumulateChunk = accumulateChunk;
+exports.accumulateNetworkChunk = accumulateNetworkChunk;
 exports.finishStreamingAssistantMessage = finishStreamingAssistantMessage;
+exports.fromCoreUserMessageToMastraDBMessage = fromCoreUserMessageToMastraDBMessage;
 exports.mapWorkflowStreamChunkToWatchResult = mapWorkflowStreamChunkToWatchResult;
-exports.markStreamingPartsDone = markStreamingPartsDone;
-exports.resolveToChildMessages = resolveToChildMessages;
-exports.toAssistantUIMessage = toAssistantUIMessage;
-exports.toUIMessage = toUIMessage;
 exports.useCancelWorkflowRun = useCancelWorkflowRun;
 exports.useChat = useChat;
 exports.useCreateWorkflowRun = useCreateWorkflowRun;