@convex-dev/agent 0.2.3-alpha.0 → 0.2.4-alpha.0

package/src/react/deltas.ts

@@ -1,16 +1,26 @@
-import type { ProviderMetadata, TextStreamPart, ToolSet } from "ai";
-import type { MessageDoc } from "../client/index.js";
 import type {
-  Message,
-  MessageStatus,
-  StreamDelta,
-  StreamMessage,
-  vReasoningPart,
-  vTextPart,
-  vToolCallPart,
-  vToolResultPart,
+  ProviderMetadata,
+  TextStreamPart,
+  ToolSet,
+  UIMessageChunk,
+} from "ai";
+import type { MessageDoc } from "../client/index.js";
+import {
+  vSource,
+  type Message,
+  type MessageStatus,
+  type StreamDelta,
+  type StreamMessage,
+  type vFilePart,
+  type vReasoningPart,
+  type vTextPart,
+  type vToolCallPart,
+  type vToolResultPart,
 } from "../validators.js";
 import type { Infer } from "convex/values";
+import { serializeWarnings } from "../mapping.js";
+import { parse } from "convex-helpers/validators";
+import { sorted } from "../shared.js";
 
 export function mergeDeltas(
   threadId: string,
@@ -55,10 +65,7 @@ export function mergeDeltas(
       changed = true;
     }
   }
-  const messages = newStreams
-    .map((s) => s.messages)
-    .flat()
-    .sort((a, b) => a.order - b.order || a.stepOrder - b.stepOrder);
+  const messages = sorted(newStreams.map((s) => s.messages).flat());
   return [messages, newStreams, changed];
 }
 
@@ -73,7 +80,7 @@ export function applyDeltasToStreamMessage(
 ): [{ streamId: string; cursor: number; messages: MessageDoc[] }, boolean] {
   let changed = false;
   let cursor = existing?.cursor ?? 0;
-  let parts: TextStreamPart<ToolSet>[] = [];
+  let parts: (UIMessageChunk<ToolSet> | TextStreamPart<ToolSet>)[] = [];
   for (const delta of deltas.sort((a, b) => a.start - b.start)) {
     if (delta.parts.length === 0) {
       console.warn(`Got delta with no parts: ${JSON.stringify(delta)}`);
@@ -146,6 +153,7 @@ export function applyDeltasToStreamMessage(
       | Infer<typeof vToolCallPart>
       | Infer<typeof vToolResultPart>
       | Infer<typeof vReasoningPart>
+      | Infer<typeof vFilePart>
       | undefined;
     const isToolRole = part.type === "source" || part.type === "tool-result";
     if (isToolRole !== (currentMessage.message!.role === "tool")) {
@@ -161,25 +169,52 @@ export function applyDeltasToStreamMessage(
     }
     switch (part.type) {
       case "text-delta": {
-        const text = part.text;
+        const text = "text" in part ? part.text : part.delta;
+        if (!text) {
+          console.warn("Got text delta with no text", part);
+        }
         currentMessage.text = (currentMessage.text ?? "") + text;
         if (lastContent?.type === "text") {
           lastContent.text = (lastContent.text ?? "") + text;
+          lastContent.providerMetadata = mergeProviderMetadata(
+            lastContent.providerMetadata,
+            part.providerMetadata,
+          );
+        } else {
+          contentToAdd = {
+            type: "text",
+            providerMetadata: part.providerMetadata,
+            text,
+          } satisfies Infer<typeof vTextPart>;
+        }
+        break;
+      }
+      case "tool-input-available": {
+        if (
+          lastContent?.type === "tool-call" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          lastContent.args = part.input;
+          lastContent.providerExecuted ??= part.providerExecuted;
+          lastContent.providerMetadata = mergeProviderMetadata(
+            lastContent.providerMetadata,
+            part.providerMetadata,
+          );
         } else {
-          contentToAdd = { type: "text", text } satisfies Infer<
-            typeof vTextPart
-          >;
+          contentToAdd = toolCallContent(part);
         }
         break;
       }
       case "tool-input-start": {
-        const toolCallId = part.id;
+        const toolCallId = "id" in part ? part.id : part.toolCallId;
         currentMessage.tool = true;
         contentToAdd = {
           type: "tool-call",
           toolCallId,
           toolName: part.toolName,
           args: "",
+          providerMetadata:
+            "providerMetadata" in part ? part.providerMetadata : undefined,
           providerExecuted:
             "providerExecuted" in part ? part.providerExecuted : undefined,
         } satisfies Infer<typeof vToolCallPart>;
@@ -192,11 +227,22 @@ export function applyDeltasToStreamMessage(
             throw new Error("Expected last content to be a tool call");
           }
           if (typeof lastContent.args !== "string") {
-            throw new Error("Expected args to be a string");
+            lastContent.args = lastContent.args?.toString() ?? "";
           }
           const delta =
-            "argsTextDelta" in part ? part.argsTextDelta : part.delta;
-          lastContent.args = (lastContent.args ?? "") + delta;
+            "inputTextDelta" in part
+              ? part.inputTextDelta
+              : "delta" in part
+                ? part.delta
+                : "";
+          lastContent.args = lastContent.args + delta;
+          lastContent.providerMetadata =
+            "providerMetadata" in part
+              ? mergeProviderMetadata(
+                  lastContent.providerMetadata,
+                  part.providerMetadata,
+                )
+              : undefined;
         }
         break;
       case "tool-call": {
@@ -204,18 +250,50 @@ export function applyDeltasToStreamMessage(
         contentToAdd = toolCallContent(part);
         break;
       }
+      case "tool-output-available":
+        if (
+          lastContent?.type === "tool-call" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          contentToAdd = {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: lastContent.toolName,
+            args: lastContent.args,
+            result: part.output,
+            providerExecuted: part.providerExecuted,
+          } satisfies Infer<typeof vToolResultPart>;
+        } else if (
+          lastContent?.type === "tool-result" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          lastContent.result = part.output;
+          lastContent.providerExecuted = part.providerExecuted;
+        } else {
+          console.warn(
+            "Got tool output available part for unknown tool call",
+            part,
+          );
+        }
+        break;
       case "tool-result": {
         contentToAdd = toolResultContent(part);
         break;
       }
       case "reasoning-delta": {
-        currentMessage.reasoning = (currentMessage.reasoning ?? "") + part.text;
+        const text = "text" in part ? part.text : part.delta;
+        currentMessage.reasoning = (currentMessage.reasoning ?? "") + text;
         if (lastContent?.type === "reasoning") {
-          lastContent.text = (lastContent.text ?? "") + part.text;
+          lastContent.text = (lastContent.text ?? "") + text;
+          lastContent.providerMetadata = mergeProviderMetadata(
+            lastContent.providerMetadata,
+            part.providerMetadata,
+          );
         } else {
           contentToAdd = {
             type: "reasoning",
-            text: part.text,
+            text,
+            providerMetadata: part.providerMetadata,
           } satisfies Infer<typeof vReasoningPart>;
         }
         break;
@@ -224,20 +302,158 @@ export function applyDeltasToStreamMessage(
         if (!currentMessage.sources) {
           currentMessage.sources = [];
         }
-        currentMessage.sources.push(part);
+        currentMessage.sources.push(parse(vSource, part));
+        console.warn("Got source part with unknown source type", part);
+        break;
+      case "abort":
+        currentMessage.status = "failed";
+        currentMessage.error = "abort";
+        break;
+      case "error":
+        currentMessage.status = "failed";
+        currentMessage.error =
+          "error" in part ? part.error?.toString() : part.errorText;
+        break;
+      case "message-metadata":
+        currentMessage.providerMetadata ??= {};
+        currentMessage.providerMetadata["metadata"] = {
+          parts: [part.messageMetadata],
+        };
+        console.warn(
+          "Putting message metadata part in providerMetadata. Use useUIMessages or useStreamingUIMessages instead.",
+          part,
+        );
+        break;
+      case "source-document":
+        contentToAdd = {
+          type: "file",
+          data: part.sourceId,
+          mimeType: part.mediaType,
+          filename: part.title ?? part.filename,
+          providerMetadata: part.providerMetadata,
+        } satisfies Infer<typeof vFilePart>;
+        break;
+      case "source-url":
+        contentToAdd = {
+          type: "file",
+          data: part.url,
+          filename: part.title,
+          mimeType: "text/plain", // What do we do here?
+          providerMetadata: part.providerMetadata,
+        } satisfies Infer<typeof vFilePart>;
+        break;
+      case "tool-input-error":
+        if (
+          lastContent?.type === "tool-call" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          lastContent.args ||= part.input;
+          lastContent.providerExecuted ??= part.providerExecuted;
+          lastContent.providerMetadata = mergeProviderMetadata(
+            lastContent.providerMetadata,
+            part.providerMetadata,
+          );
+        } else {
+          if (
+            lastContent?.type === "tool-result" &&
+            lastContent.toolCallId === part.toolCallId
+          ) {
+            lastContent.isError = true;
+            lastContent.providerExecuted ??= part.providerExecuted;
+            lastContent.providerMetadata = mergeProviderMetadata(
+              lastContent.providerMetadata,
+              part.providerMetadata,
+            );
+          } else {
+            contentToAdd = toolCallContent(part);
+          }
+        }
+        currentMessage.error = part.errorText;
+        break;
+      case "tool-output-error":
+        if (
+          lastContent?.type === "tool-result" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          lastContent.isError = true;
+          lastContent.result = part.errorText;
+          lastContent.providerExecuted = part.providerExecuted;
+        } else if (
+          lastContent?.type === "tool-call" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          console.warn(
+            "Got tool output error part for unknown tool result",
+            part,
+          );
+          contentToAdd = {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: lastContent.toolName,
+            args: lastContent.args,
+            result: part.errorText,
+            providerExecuted: part.providerExecuted,
+            isError: true,
+          } satisfies Infer<typeof vToolResultPart>;
+        } else {
+          console.warn(
+            "Got tool output error part for unknown tool call",
+            part,
+          );
+        }
+        break;
+      case "tool-error":
+        if (
+          lastContent?.type === "tool-result" &&
+          lastContent.toolCallId === part.toolCallId
+        ) {
+          lastContent.isError = true;
+          lastContent.result = part.error;
+          lastContent.providerExecuted = part.providerExecuted;
+        } else {
+          if (
+            lastContent?.type === "tool-call" &&
+            lastContent.toolCallId === part.toolCallId
+          ) {
+            lastContent.args ||= part.input;
+            lastContent.providerExecuted ??= part.providerExecuted;
+          }
+          currentMessage.error = part.error?.toString();
+          contentToAdd = {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            result: part.error,
+            providerExecuted: part.providerExecuted,
+            isError: true,
+            args: part.input,
+          } satisfies Infer<typeof vToolResultPart>;
+        }
         break;
+      case "tool-input-end":
+      case "text-end":
+      case "reasoning-end":
+      case "finish-step":
+      case "finish":
+      case "file":
       case "raw":
+      case "start-step":
+      case "text-start":
+      case "reasoning-start":
+      case "start":
         // ignore
         break;
-      default:
-        console.warn(`Received unexpected part: ${JSON.stringify(part)}`);
+      default: {
+        if (!part.type.startsWith("data-")) {
+          console.warn(`Received unexpected part: ${JSON.stringify(part)}`);
+        } else {
+          console.warn(
+            "Dropping a data part. Use useUIMessages or useStreamingUIMessages instead for full UIMessage streaming support.",
+            part,
+          );
+        }
         break;
-    }
-    if ("providerMetadata" in part) {
-      currentMessage.providerMetadata = mergeProviderMetadata(
-        currentMessage.providerMetadata,
-        part.providerMetadata,
-      );
+      }
     }
     if (contentToAdd) {
       if (!currentMessage.message!.content) {
@@ -278,7 +494,10 @@ function mergeProviderMetadata(
 }
 
 function toolCallContent(
-  part: Extract<TextStreamPart<ToolSet>, { type: "tool-call" }>,
+  part:
+    | Extract<TextStreamPart<ToolSet>, { type: "tool-call" }>
+    | Extract<UIMessageChunk<ToolSet>, { type: "tool-input-error" }>
+    | Extract<UIMessageChunk<ToolSet>, { type: "tool-input-available" }>,
 ): Infer<typeof vToolCallPart> {
   const args = "args" in part ? part.args : part.input;
   return {
@@ -286,6 +505,7 @@ function toolCallContent(
     toolCallId: part.toolCallId,
     toolName: part.toolName,
     args,
+    providerMetadata: part.providerMetadata,
     providerExecuted: part.providerExecuted,
   } satisfies Infer<typeof vToolCallPart>;
 }
@@ -342,7 +562,7 @@ function statusFromStreamStatus(
 export function createStreamingMessage(
   threadId: string,
   message: StreamMessage,
-  part: TextStreamPart<ToolSet>,
+  part: UIMessageChunk<ToolSet> | TextStreamPart<ToolSet>,
   index: number,
 ): MessageDoc {
   const { streamId, ...rest } = message;
@@ -354,15 +574,19 @@ export function createStreamingMessage(
     threadId,
     tool: false,
   };
-  if ("providerMetadata" in part) {
-    metadata.providerMetadata = part.providerMetadata;
-  }
+  const providerMetadata =
+    "providerMetadata" in part ? part.providerMetadata : undefined;
+  metadata.providerMetadata = providerMetadata;
+
   switch (part.type) {
     case "text-delta": {
-      const text = part.text || "";
+      const text = "text" in part ? part.text : part.delta;
       return {
         ...metadata,
-        message: { role: "assistant", content: [{ type: "text", text }] },
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text, providerMetadata }],
+        },
         text,
       };
     }
@@ -376,10 +600,11 @@ export function createStreamingMessage(
             {
               type: "tool-call",
               toolName: part.toolName,
-              toolCallId: part.id,
+              toolCallId: "id" in part ? part.id : part.toolCallId,
               args: "", // when it's a string, it's a partial call
               providerExecuted:
                 "providerExecuted" in part ? part.providerExecuted : undefined,
+              providerMetadata,
             },
           ],
         },
@@ -387,15 +612,23 @@ export function createStreamingMessage(
     }
     case "tool-input-delta": {
       console.warn("Received tool call delta part first??");
-      const delta = part.delta;
-      const toolCallId = part.id;
+      const delta = "delta" in part ? part.delta : part.inputTextDelta;
+      const toolCallId = "id" in part ? part.id : part.toolCallId;
       const toolName = part.type.slice("tool-".length);
       return {
         ...metadata,
         tool: true,
         message: {
           role: "assistant",
-          content: [{ type: "tool-call", toolCallId, toolName, args: delta }],
+          content: [
+            {
+              type: "tool-call",
+              toolCallId,
+              toolName,
+              args: delta,
+              providerMetadata,
+            },
+          ],
         },
       };
     }
@@ -413,13 +646,20 @@ export function createStreamingMessage(
         message: { role: "tool", content: [toolResultContent(part)] },
       };
     case "reasoning-delta": {
+      const text = "text" in part ? part.text : part.delta;
       return {
         ...metadata,
         message: {
           role: "assistant",
-          content: [{ type: "reasoning", text: part.text }],
+          content: [
+            {
+              type: "reasoning",
+              text,
+              providerMetadata,
+            },
+          ],
         },
-        reasoning: part.text,
+        reasoning: text,
       };
     }
     case "source":
@@ -430,6 +670,86 @@ export function createStreamingMessage(
         message: { role: "tool", content: [] },
         sources: [part],
       };
+    case "raw":
+    case "start":
+      return {
+        ...metadata,
+        tool: false,
+        message: { role: "assistant", content: [] },
+      };
+    case "start-step":
+      return {
+        ...metadata,
+        message: { role: "assistant", content: [] },
+        ...("warnings" in part && part.warnings?.length > 0
+          ? { warnings: serializeWarnings(part.warnings) }
+          : {}),
+      };
+    case "reasoning-start":
+      return {
+        ...metadata,
+        message: { role: "assistant", content: [] },
+        reasoning: "",
+      };
+    case "abort":
+      return {
+        ...metadata,
+        message: { role: "assistant", content: [] },
+        status: "failed",
+        error: "abort",
+      };
+    case "tool-error":
+      return {
+        ...metadata,
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              args: part.input,
+              toolName: part.toolName,
+              providerExecuted: part.providerExecuted,
+              providerMetadata,
+            },
+            {
+              type: "tool-result",
+              result: part.error,
+              toolCallId: part.toolCallId,
+              isError: true,
+              args: part.input,
+              toolName: part.toolName,
+              providerExecuted: part.providerExecuted,
+            },
+          ],
+        },
+        error: part.error?.toString(),
+      };
+    case "text-start":
+      return {
+        ...metadata,
+        message: { role: "assistant", content: [] },
+        providerMetadata,
+        id: part.id,
+        _id: part.id,
+      };
+    case "error": {
+      const errorMessage: MessageDoc = {
+        ...metadata,
+        message: {
+          role: "assistant",
+          content: [],
+        },
+      };
+      if ("error" in part) {
+        errorMessage.error = part.error?.toString();
+      } else if (part.errorText) {
+        errorMessage.error = part.errorText;
+      } else {
+        console.warn("Got an error delta with no error", part);
+      }
+      return errorMessage;
+    }
     // case "raw":
     //   return {
     //     ...metadata,