@convex-dev/agent 0.1.18-alpha.1 → 0.5.0-alpha.1

package/src/react/deltas.ts

@@ -1,4 +1,3 @@
-import type { TextPart, ToolCallPart, ToolResultPart } from "ai";
 import type { MessageDoc } from "../client/index.js";
 import type {
   Message,
@@ -6,11 +5,13 @@ import type {
   StreamDelta,
   StreamMessage,
   TextStreamPart,
+  vReasoningPart,
+  vSource,
+  vTextPart,
+  vToolCallPart,
+  vToolResultPart,
 } from "../validators.js";
-import type { UIMessage } from "./toUIMessages.js";
-import { toUIMessages } from "./toUIMessages.js";
-
-export { toUIMessages, type UIMessage };
+import type { Infer } from "convex/values";
 
 export function mergeDeltas(
   threadId: string,
@@ -142,10 +143,10 @@ export function applyDeltasToStreamMessage(
   let lastContent = getLastContent(currentMessage);
   for (const part of parts) {
     let contentToAdd:
-      | TextPart
-      | ToolCallPart
-      | { type: "reasoning"; text: string }
-      | ToolResultPart
+      | Infer<typeof vTextPart>
+      | Infer<typeof vToolCallPart>
+      | Infer<typeof vToolResultPart>
+      | Infer<typeof vReasoningPart>
       | undefined;
     const isToolRole = part.type === "source" || part.type === "tool-result";
     if (isToolRole !== (currentMessage.message!.role === "tool")) {
@@ -160,27 +161,36 @@ export function applyDeltasToStreamMessage(
       continue;
     }
     switch (part.type) {
-      case "text-delta":
-        currentMessage.text = (currentMessage.text ?? "") + part.textDelta;
+      case "text-delta": {
+        const text = "text" in part ? part.text : part.textDelta;
+        currentMessage.text = (currentMessage.text ?? "") + text;
         if (lastContent?.type === "text") {
-          lastContent.text = (lastContent.text ?? "") + part.textDelta;
+          lastContent.text = (lastContent.text ?? "") + text;
         } else {
-          contentToAdd = {
-            type: "text",
-            text: part.textDelta,
-          };
+          contentToAdd = { type: "text", text } satisfies Infer<
+            typeof vTextPart
+          >;
         }
         break;
-      case "tool-call-streaming-start":
+      }
+      case "tool-input-start":
+      case "tool-call-streaming-start": {
+        const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
         currentMessage.tool = true;
         contentToAdd = {
           type: "tool-call",
-          toolCallId: part.toolCallId,
+          toolCallId,
           toolName: part.toolName,
           args: "",
-        };
+          providerExecuted:
+            "providerExecuted" in part ? part.providerExecuted : undefined,
+          providerOptions:
+            "providerMetadata" in part ? part.providerMetadata : undefined,
+        } satisfies Infer<typeof vToolCallPart>;
         break;
+      }
       case "tool-call-delta":
+      case "tool-input-delta":
         {
           currentMessage.tool = true;
           if (lastContent?.type !== "tool-call") {
@@ -189,13 +199,20 @@ export function applyDeltasToStreamMessage(
           if (typeof lastContent.args !== "string") {
             throw new Error("Expected args to be a string");
           }
-          lastContent.args = (lastContent.args ?? "") + part.argsTextDelta;
+          const delta =
+            "argsTextDelta" in part ? part.argsTextDelta : part.delta;
+          lastContent.args = (lastContent.args ?? "") + delta;
         }
         break;
-      case "tool-call":
+      case "tool-call": {
         currentMessage.tool = true;
-        contentToAdd = part;
+        contentToAdd = toolCallContent(part);
+        break;
+      }
+      case "tool-result": {
+        contentToAdd = toolResultContent(part);
         break;
+      }
       case "reasoning":
         currentMessage.reasoning =
           (currentMessage.reasoning ?? "") + part.textDelta;
@@ -208,14 +225,36 @@ export function applyDeltasToStreamMessage(
           };
         }
         break;
+      case "reasoning-delta": {
+        currentMessage.reasoning = (currentMessage.reasoning ?? "") + part.text;
+        if (lastContent?.type === "reasoning") {
+          lastContent.text = (lastContent.text ?? "") + part.text;
+        } else {
+          contentToAdd = {
+            type: "reasoning",
+            text: part.text,
+            providerOptions:
+              "providerMetadata" in part ? part.providerMetadata : undefined,
+            state: "streaming",
+          } satisfies Infer<typeof vReasoningPart>;
+        }
+        break;
+      }
       case "source":
         if (!currentMessage.sources) {
           currentMessage.sources = [];
         }
-        currentMessage.sources.push(part.source);
+        if ("source" in part) {
+          currentMessage.sources.push({
+            type: "source",
+            ...part.source,
+          } satisfies Infer<typeof vSource>);
+        } else {
+          currentMessage.sources.push(part);
+        }
         break;
-      case "tool-result":
-        contentToAdd = part;
+      case "raw":
+        contentToAdd = part.rawValue;
         break;
       default:
         console.warn(`Received unexpected part: ${JSON.stringify(part)}`);
@@ -236,6 +275,35 @@ export function applyDeltasToStreamMessage(
   return [newStream, true];
 }
 
+function toolCallContent(
+  part: Extract<TextStreamPart, { type: "tool-call" }>,
+): Infer<typeof vToolCallPart> {
+  const args = "args" in part ? part.args : part.input;
+  return {
+    type: "tool-call",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    args,
+    providerExecuted: part.providerExecuted,
+  } satisfies Infer<typeof vToolCallPart>;
+}
+
+function toolResultContent(
+  part: Extract<TextStreamPart, { type: "tool-result" }>,
+): Infer<typeof vToolResultPart> {
+  const result =
+    "output" in part ? part.output : "result" in part ? part.result : undefined;
+  const args =
+    "input" in part ? part.input : "args" in part ? part.args : undefined;
+  return {
+    type: "tool-result",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    result,
+    args,
+    providerExecuted: part.providerExecuted,
+  } satisfies Infer<typeof vToolResultPart>;
+}
 function cloneMessageAndContent(
   message: Message | undefined,
 ): Message | undefined {
@@ -272,6 +340,7 @@ function statusFromStreamStatus(
   }
 }
 
+// TODO: share more code with applyDeltasToStreamMessage
 export function createStreamingMessage(
   threadId: string,
   message: StreamMessage,
@@ -288,16 +357,20 @@ export function createStreamingMessage(
     tool: false,
   };
   switch (part.type) {
-    case "text-delta":
+    case "text-delta": {
+      const text = "text" in part ? part.text : part.textDelta;
       return {
         ...metadata,
         message: {
           role: "assistant",
-          content: [{ type: "text", text: part.textDelta }],
+          content: [{ type: "text", text }],
         },
-        text: part.textDelta,
+        text,
       };
-    case "tool-call-streaming-start":
+    }
+    case "tool-input-start":
+    case "tool-call-streaming-start": {
+      const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
       return {
         ...metadata,
         tool: true,
@@ -307,58 +380,98 @@ export function createStreamingMessage(
             {
               type: "tool-call",
               toolName: part.toolName,
-              toolCallId: part.toolCallId,
+              toolCallId,
               args: "", // when it's a string, it's a partial call
+              providerExecuted:
+                "providerExecuted" in part ? part.providerExecuted : undefined,
+              providerOptions:
+                "providerMetadata" in part ? part.providerMetadata : undefined,
             },
           ],
         },
       };
-    case "reasoning":
+    }
+    case "tool-input-delta":
+    case "tool-call-delta": {
+      console.warn("Received tool call delta part first??");
+      const delta = "argsTextDelta" in part ? part.argsTextDelta : part.delta;
+      const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
+      const toolName =
+        "toolName" in part ? part.toolName : part.type.slice("tool-".length);
       return {
         ...metadata,
+        tool: true,
         message: {
           role: "assistant",
-          content: [{ type: "reasoning", text: part.textDelta }],
+          content: [
+            {
+              type: "tool-call",
+              toolCallId,
+              toolName,
+              args: delta,
+            },
+          ],
         },
-        reasoning: part.textDelta,
       };
-    case "source":
-      console.warn("Received source part first??");
+    }
+    case "tool-call": {
       return {
         ...metadata,
         tool: true,
-        message: { role: "tool", content: [] },
-        sources: [part.source],
+        message: {
+          role: "assistant",
+          content: [toolCallContent(part)],
+        },
       };
-    case "tool-call":
+    }
+    case "tool-result":
       return {
         ...metadata,
         tool: true,
-        message: { role: "assistant", content: [part] },
+        message: {
+          role: "tool",
+          content: [toolResultContent(part)],
+        },
       };
-    case "tool-call-delta":
-      console.warn("Received tool call delta part first??");
+    case "reasoning":
       return {
         ...metadata,
-        tool: true,
         message: {
           role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              args: part.argsTextDelta,
-            },
-          ],
+          content: [{ type: "reasoning", text: part.textDelta }],
         },
+        reasoning: part.textDelta,
       };
-    case "tool-result":
+    case "reasoning-delta": {
+      return {
+        ...metadata,
+        message: {
+          role: "assistant",
+          content: [{ type: "reasoning", text: part.text }],
+        },
+        reasoning: part.text,
+      };
+    }
+    case "source":
+      console.warn("Received source part first??");
       return {
         ...metadata,
         tool: true,
-        message: { role: "tool", content: [part] },
+        message: { role: "tool", content: [] },
+        sources: [
+          "source" in part
+            ? {
+                ...part.source,
+                type: "source",
+              }
+            : part,
+        ],
       };
+    // case "raw":
+    //   return {
+    //     ...metadata,
+    //     message: { role: "assistant", content: [part.rawValue] },
+    //   };
     default:
       throw new Error(`Unexpected part type: ${JSON.stringify(part)}`);
   }

package/src/react/optimisticallySendMessage.ts

@@ -46,7 +46,10 @@ export function optimisticallySendMessage(
 }
 
 export function randomUUID() {
-  if (typeof crypto !== "undefined") {
+  if (
+    typeof crypto !== "undefined" &&
+    typeof crypto.randomUUID === "function"
+  ) {
     return crypto.randomUUID();
   }
   return (

package/src/react/toUIMessages.test.ts

@@ -31,7 +31,7 @@ describe("toUIMessages", () => {
     const uiMessages = toUIMessages(messages);
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("user");
-    expect(uiMessages[0].content).toBe("Hello!");
+    expect(uiMessages[0].text).toBe("Hello!");
     expect(uiMessages[0].parts[0]).toEqual({ type: "text", text: "Hello!" });
   });
 
@@ -48,10 +48,11 @@ describe("toUIMessages", () => {
     const uiMessages = toUIMessages(messages);
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("assistant");
-    expect(uiMessages[0].content).toBe("Hi, how can I help?");
+    expect(uiMessages[0].text).toBe("Hi, how can I help?");
     expect(uiMessages[0].parts[0]).toEqual({
       type: "text",
       text: "Hi, how can I help?",
+      state: "done",
     });
   });
 
@@ -83,13 +84,13 @@ describe("toUIMessages", () => {
             {
               type: "file",
               mimeType: "text/plain",
-              data: "asdfasdfasdf",
+              data: "https://example.com/file.txt",
             },
             {
               type: "tool-call",
               toolName: "myTool",
               toolCallId: "call1",
-              args: "",
+              args: "an arg",
             },
           ],
         },
@@ -109,7 +110,6 @@ describe("toUIMessages", () => {
             },
           ],
         },
-        text: "42",
         tool: true,
       }),
     ];
@@ -121,18 +121,15 @@ describe("toUIMessages", () => {
     );
     expect(uiMessages[1].role).toBe("assistant");
     expect(
-      uiMessages[1].parts.filter((p) => p.type === "tool-invocation"),
+      uiMessages[1].parts.filter((p) => p.type === "tool-myTool"),
     ).toHaveLength(1);
     expect(
-      uiMessages[1].parts.filter((p) => p.type === "tool-invocation")[0]
-        .toolInvocation,
-    ).toEqual({
-      toolName: "myTool",
+      uiMessages[1].parts.filter((p) => p.type === "tool-myTool")[0],
+    ).toMatchObject({
+      type: "tool-myTool",
       toolCallId: "call1",
-      args: "",
-      state: "result",
-      result: "42",
-      step: 0,
+      state: "output-available",
+      output: "42",
     });
   });
 
@@ -167,21 +164,39 @@ describe("toUIMessages", () => {
     const uiMessages = toUIMessages(messages);
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("assistant");
-    expect(uiMessages[0].content).toBe("Here's one idea. Here's another idea.");
-    expect(
-      uiMessages[0].parts.filter((p) => p.type === "reasoning"),
-    ).toHaveLength(1);
+    expect(uiMessages[0].text).toBe("Here's one idea. Here's another idea.");
+    expect(uiMessages[0].parts.filter((p) => p.type === "reasoning")).toEqual([
+      {
+        providerMetadata: undefined,
+        state: undefined,
+        text: "I'm thinking...",
+        type: "reasoning",
+      },
+      {
+        providerMetadata: undefined,
+        state: undefined,
+        text: "I'm thinking...",
+        type: "reasoning",
+      },
+    ]);
     expect(uiMessages[0].parts[0].type).toBe("reasoning");
     assert(uiMessages[0].parts[0].type === "reasoning");
-    expect(uiMessages[0].parts[0].reasoning).toBe(
-      "I'm thinking...I'm thinking...",
-    );
+    expect(uiMessages[0].parts[0].text).toBe("I'm thinking...");
+    expect(uiMessages[0].parts[1].type).toBe("text");
+    assert(uiMessages[0].parts[1].type === "text");
+    expect(uiMessages[0].parts[1].text).toBe("Here's one idea.");
+    expect(uiMessages[0].parts[2].type).toBe("reasoning");
+    assert(uiMessages[0].parts[2].type === "reasoning");
+    expect(uiMessages[0].parts[2].text).toBe("I'm thinking...");
 
     expect(uiMessages[0].parts.filter((p) => p.type === "text")).toHaveLength(
-      1,
+      2,
     );
     expect(uiMessages[0].parts.filter((p) => p.type === "text")[0].text).toBe(
-      "Here's one idea. Here's another idea.",
+      "Here's one idea.",
+    );
+    expect(uiMessages[0].parts.filter((p) => p.type === "text")[1].text).toBe(
+      "Here's another idea.",
     );
   });
 
@@ -198,10 +213,58 @@ describe("toUIMessages", () => {
     const uiMessages = toUIMessages(messages);
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("system");
-    expect(uiMessages[0].content).toBe("System message here");
+    expect(uiMessages[0].text).toBe("System message here");
     expect(uiMessages[0].parts[0]).toEqual({
       type: "text",
       text: "System message here",
+      state: "done",
+      providerMetadata: undefined,
+    });
+  });
+
+  it("handles wrapped JSON tool output", () => {
+    const messages = [
+      baseMessageDoc({
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolName: "myTool",
+              toolCallId: "call1",
+              args: { query: "test" },
+            },
+          ],
+        },
+        tool: true,
+      }),
+      baseMessageDoc({
+        message: {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolName: "myTool",
+              toolCallId: "call1",
+              result: {
+                type: "json",
+                value: { data: "wrapped result", success: true },
+              },
+            },
+          ],
+        },
+        tool: true,
+      }),
+    ];
+    const uiMessages = toUIMessages(messages);
+    expect(uiMessages).toHaveLength(1);
+    const toolPart = uiMessages[0].parts.find((p) => p.type === "tool-myTool");
+    expect(toolPart).toMatchObject({
+      type: "tool-myTool",
+      toolCallId: "call1",
+      state: "output-available",
+      input: { query: "test" },
+      output: { data: "wrapped result", success: true }, // Should be unwrapped
     });
   });
 
@@ -215,7 +278,7 @@ describe("toUIMessages", () => {
               type: "tool-call",
               toolName: "myTool",
               toolCallId: "call1",
-              args: "",
+              args: "hi",
             },
           ],
         },
@@ -226,17 +289,12 @@ describe("toUIMessages", () => {
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("assistant");
     expect(
-      uiMessages[0].parts.filter((p) => p.type === "tool-invocation"),
-    ).toHaveLength(1);
-    expect(
-      uiMessages[0].parts.filter((p) => p.type === "tool-invocation")[0]
-        .toolInvocation,
-    ).toEqual({
-      toolName: "myTool",
+      uiMessages[0].parts.filter((p) => p.type === "tool-myTool")[0],
+    ).toMatchObject({
+      type: "tool-myTool",
       toolCallId: "call1",
-      args: "",
-      state: "call",
-      step: 0,
+      input: "hi",
+      state: "input-available",
     });
   });
 
@@ -276,7 +334,7 @@ describe("toUIMessages", () => {
     expect(uiMessages).toHaveLength(1);
     expect(uiMessages[0].role).toBe("assistant");
     // Should have a tool-invocation part
-    expect(uiMessages[0].parts.some((p) => p.type === "tool-invocation")).toBe(
+    expect(uiMessages[0].parts.some((p) => p.type === "tool-myTool")).toBe(
       true,
     );
   });
@@ -299,4 +357,64 @@ describe("toUIMessages", () => {
   });
 
   // Add more tests for array content, tool calls, etc. as needed
+
+  it("should update tool call state from input-available to output-available", () => {
+    const messages = [
+      baseMessageDoc({
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              toolName: "calculator",
+              toolCallId: "call1",
+              args: { operation: "add", a: 1, b: 2 },
+            },
+          ],
+        },
+        tool: true,
+      }),
+      baseMessageDoc({
+        message: {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: "call1",
+              toolName: "calculator",
+              result: { sum: 3 },
+            },
+          ],
+        },
+        tool: true,
+      }),
+    ];
+
+    const uiMessages = toUIMessages(messages);
+
+    // Should have one assistant message
+    expect(uiMessages).toHaveLength(1);
+    expect(uiMessages[0].role).toBe("assistant");
+
+    // Should have a single tool-calculator part (not separate tool-call and tool-result parts)
+    const toolParts = uiMessages[0].parts.filter(
+      (p) => p.type === "tool-calculator",
+    );
+    expect(toolParts).toHaveLength(1);
+
+    const toolPart = toolParts[0];
+    expect(toolPart).toMatchObject({
+      type: "tool-calculator",
+      toolCallId: "call1",
+      state: "output-available",
+      input: { operation: "add", a: 1, b: 2 },
+      output: { sum: 3 },
+    });
+
+    // Should NOT have a tool-call part (which is what currently happens)
+    const toolCallParts = uiMessages[0].parts.filter(
+      (p) => p.type === "tool-call",
+    );
+    expect(toolCallParts).toHaveLength(0);
+  });
 });