@convex-dev/agent 0.3.2 → 0.6.0-alpha.0

package/src/UIMessages.combineUIMessages.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect } from "vitest";
+import { combineUIMessages, type UIMessage } from "./UIMessages.js";
+
+describe("combineUIMessages", () => {
+  it("should preserve all tool calls when combining messages", () => {
+    const messages: UIMessage[] = [
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolB",
+            toolCallId: "call_B",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+    ];
+
+    const result = combineUIMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].parts).toHaveLength(2);
+
+    const toolCallIds = result[0].parts
+      .filter((p) => p.type.startsWith("tool-"))
+      .map((p: any) => p.toolCallId);
+
+    expect(toolCallIds).toContain("call_A");
+    expect(toolCallIds).toContain("call_B");
+  });
+
+  it("should accumulate tool calls progressively (issue #182)", () => {
+    // Simulating: A(started) → B → C → A(result)
+    const messages: UIMessage[] = [
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "input-available",
+            input: {},
+          },
+          {
+            type: "tool-toolB",
+            toolCallId: "call_B",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "input-available",
+            input: {},
+          },
+          {
+            type: "tool-toolB",
+            toolCallId: "call_B",
+            state: "input-available",
+            input: {},
+          },
+          {
+            type: "tool-toolC",
+            toolCallId: "call_C",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "success",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "output-available",
+            input: {},
+            output: "success",
+          },
+          {
+            type: "tool-toolB",
+            toolCallId: "call_B",
+            state: "input-available",
+            input: {},
+          },
+          {
+            type: "tool-toolC",
+            toolCallId: "call_C",
+            state: "input-available",
+            input: {},
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+    ];
+
+    const result = combineUIMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].parts).toHaveLength(3);
+
+    const toolCallIds = result[0].parts
+      .filter((p) => p.type.startsWith("tool-"))
+      .map((p: any) => p.toolCallId);
+
+    // All tool calls should be present
+    expect(toolCallIds).toContain("call_A");
+    expect(toolCallIds).toContain("call_B");
+    expect(toolCallIds).toContain("call_C");
+
+    // Tool A should have the final state (output-available)
+    const toolA = result[0].parts.find(
+      (p: any) => p.type === "tool-toolA" && p.toolCallId === "call_A",
+    ) as any;
+    expect(toolA.state).toBe("output-available");
+    expect(toolA.output).toBe("success");
+  });
+
+  it("should merge tool calls with same toolCallId", () => {
+    const messages: UIMessage[] = [
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "streaming",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "input-available",
+            input: { test: "input" },
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+      {
+        id: "msg1",
+        key: "thread-1-0",
+        order: 1,
+        stepOrder: 0,
+        status: "success",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-toolA",
+            toolCallId: "call_A",
+            state: "output-available",
+            input: { test: "input" },
+            output: "completed",
+          },
+        ],
+        text: "",
+        _creationTime: Date.now(),
+      },
+    ];
+
+    const result = combineUIMessages(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].parts).toHaveLength(1);
+
+    const toolCall = result[0].parts[0] as any;
+    expect(toolCall.toolCallId).toBe("call_A");
+    expect(toolCall.state).toBe("output-available");
+    expect(toolCall.output).toBe("completed");
+  });
+});

package/src/UIMessages.ts

@@ -8,6 +8,7 @@ import {
   type SourceUrlUIPart,
   type StepStartUIPart,
   type TextUIPart,
+  type ToolResultPart,
   type ToolUIPart,
   type UIDataTypes,
   type UITools,
@@ -42,6 +43,7 @@ export type UIMessage<
   stepOrder: number;
   status: UIStatus;
   agentName?: string;
+  userId?: string;
   text: string;
   _creationTime: number;
 };
@@ -53,7 +55,7 @@ export type UIMessage<
  * @param meta - The metadata to add to the MessageDocs.
  * @returns
  */
-export function fromUIMessages<METADATA = unknown>(
+export async function fromUIMessages<METADATA = unknown>(
   messages: UIMessage<METADATA>[],
   meta: {
     threadId: string;
@@ -63,58 +65,71 @@ export function fromUIMessages<METADATA = unknown>(
     providerOptions?: ProviderOptions;
     metadata?: METADATA;
   },
-): (MessageDoc & { streaming: boolean; metadata?: METADATA })[] {
-  return messages.flatMap((uiMessage) => {
-    const stepOrder = uiMessage.stepOrder;
-    const commonFields = {
-      ...pick(meta, [
-        "threadId",
-        "userId",
-        "model",
-        "provider",
-        "providerOptions",
-        "metadata",
-      ]),
-      ...omit(uiMessage, ["parts", "role", "key", "text"]),
-      status: uiMessage.status === "streaming" ? "pending" : "success",
-      streaming: uiMessage.status === "streaming",
-      // to override
-      _id: uiMessage.id,
-      tool: false,
-    } satisfies MessageDoc & { streaming: boolean; metadata?: METADATA };
-    const modelMessages = convertToModelMessages([uiMessage]);
-    return modelMessages
-      .map((modelMessage, i) => {
-        if (modelMessage.content.length === 0) {
-          return undefined;
-        }
-        const message = fromModelMessage(modelMessage);
-        const tool = isTool(message);
-        const doc: MessageDoc & { streaming: boolean; metadata?: METADATA } = {
-          ...commonFields,
-          _id: uiMessage.id + `-${i}`,
-          stepOrder: stepOrder + i,
-          message,
-          tool,
-          text: extractText(message),
-          reasoning: extractReasoning(message),
-          finishReason: tool ? "tool-calls" : "stop",
-          sources: fromSourceParts(uiMessage.parts),
-        };
-        if (Array.isArray(modelMessage.content)) {
-          const providerOptions = modelMessage.content.find(
-            (c) => c.providerOptions,
-          )?.providerOptions;
-          if (providerOptions) {
-            // convertToModelMessages changes providerMetadata to providerOptions
-            doc.providerMetadata = providerOptions;
-            doc.providerOptions ??= providerOptions;
+): Promise<(MessageDoc & { streaming: boolean; metadata?: METADATA })[]> {
+  const nested = await Promise.all(
+    messages.map(async (uiMessage) => {
+      const stepOrder = uiMessage.stepOrder;
+      const commonFields = {
+        ...pick(meta, [
+          "threadId",
+          "userId",
+          "model",
+          "provider",
+          "providerOptions",
+          "metadata",
+        ]),
+        ...omit(uiMessage, ["parts", "role", "key", "text", "userId"]),
+        userId: uiMessage.userId ?? meta.userId,
+        status: uiMessage.status === "streaming" ? "pending" : "success",
+        streaming: uiMessage.status === "streaming",
+        // to override
+        _id: uiMessage.id,
+        tool: false,
+      } satisfies MessageDoc & { streaming: boolean; metadata?: METADATA };
+      const modelMessages = await convertToModelMessages([uiMessage]);
+      return modelMessages
+        .map((modelMessage, i) => {
+          if (modelMessage.content.length === 0) {
+            return undefined;
           }
-        }
-        return doc;
-      })
-      .filter((d) => d !== undefined);
-  });
+          const message = fromModelMessage(modelMessage);
+          const tool = isTool(message);
+          const doc: MessageDoc & { streaming: boolean; metadata?: METADATA } =
+            {
+              ...commonFields,
+              _id: uiMessage.id + `-${i}`,
+              stepOrder: stepOrder + i,
+              message,
+              tool,
+              text: extractText(message),
+              reasoning: extractReasoning(message),
+              finishReason: tool ? "tool-calls" : "stop",
+              sources: fromSourceParts(uiMessage.parts),
+            };
+          if (Array.isArray(modelMessage.content)) {
+            // Find a content part with providerOptions (type assertion needed for SDK compatibility)
+            const partWithProviderOptions = modelMessage.content.find(
+              (c): c is typeof c & { providerOptions: unknown } =>
+                "providerOptions" in c && c.providerOptions !== undefined,
+            );
+            if (partWithProviderOptions?.providerOptions) {
+              // convertToModelMessages changes providerMetadata to providerOptions
+              const providerOptions =
+                partWithProviderOptions.providerOptions as
+                  | Record<string, Record<string, unknown>>
+                  | undefined;
+              if (providerOptions) {
+                doc.providerMetadata = providerOptions;
+                doc.providerOptions ??= providerOptions;
+              }
+            }
+          }
+          return doc;
+        })
+        .filter((d) => d !== undefined);
+    }),
+  );
+  return nested.flat();
 }
 
 function fromSourceParts(parts: UIMessage["parts"]): Infer<typeof vSource>[] {
@@ -288,6 +303,7 @@ function createSystemUIMessage<
     text,
     role: "system",
     agentName: message.agentName,
+    userId: message.userId,
     parts: [{ type: "text", text, ...partCommon } satisfies TextUIPart],
     metadata: message.metadata,
   };
@@ -347,6 +363,7 @@ function createUserUIMessage<
     key: `${message.threadId}-${message.order}-${message.stepOrder}`,
     text,
     role: "user",
+    userId: message.userId,
     parts,
     metadata: message.metadata,
   };
@@ -370,6 +387,7 @@ function createAssistantUIMessage<
     stepOrder: firstMessage.stepOrder,
     key: `${firstMessage.threadId}-${firstMessage.order}-${firstMessage.stepOrder}`,
     agentName: firstMessage.agentName,
+    userId: firstMessage.userId,
   };
 
   // Get status from last message
@@ -459,10 +477,50 @@ function createAssistantUIMessage<
           break;
         }
         case "tool-result": {
+          const typedPart = contentPart as unknown as ToolResultPart & {
+            output: { type: string; value?: unknown; reason?: string };
+          };
+
+          // Check if this is an execution-denied result
+          if (typedPart.output?.type === "execution-denied") {
+            const call = allParts.find(
+              (part) =>
+                part.type === `tool-${contentPart.toolName}` &&
+                "toolCallId" in part &&
+                part.toolCallId === contentPart.toolCallId,
+            ) as ToolUIPart | undefined;
+
+            if (call) {
+              call.state = "output-denied";
+              if (!("approval" in call) || !call.approval) {
+                (call as ToolUIPart & { approval?: object }).approval = {
+                  id: "",
+                  approved: false,
+                  reason: typedPart.output.reason,
+                };
+              } else {
+                const approval = (
+                  call as ToolUIPart & {
+                    approval: { approved?: boolean; reason?: string };
+                  }
+                ).approval;
+                approval.approved = false;
+                approval.reason = typedPart.output.reason;
+              }
+            }
+            break;
+          }
+
           const output =
-            typeof contentPart.output?.type === "string"
-              ? contentPart.output.value
-              : contentPart.output;
+            typeof typedPart.output?.type === "string"
+              ? typedPart.output.value
+              : typedPart.output;
+          // Check for error at both the content part level (isError) and message level
+          // isError may exist on stored tool results but isn't in ToolResultPart type
+          const hasError =
+            (contentPart as { isError?: boolean }).isError || message.error;
+          const errorText =
+            message.error || (hasError ? String(output) : undefined);
           const call = allParts.find(
             (part) =>
               part.type === `tool-${contentPart.toolName}` &&
@@ -470,26 +528,23 @@ function createAssistantUIMessage<
               part.toolCallId === contentPart.toolCallId,
           ) as ToolUIPart | undefined;
           if (call) {
-            if (message.error) {
+            if (hasError) {
               call.state = "output-error";
-              call.errorText = message.error;
+              call.errorText = errorText ?? "Unknown error";
               call.output = output;
             } else {
               call.state = "output-available";
               call.output = output;
             }
           } else {
-            console.warn(
-              "Tool result without preceding tool call.. adding anyways",
-              contentPart,
-            );
-            if (message.error) {
+            // Tool call is on a previous page - create standalone tool part
+            if (hasError) {
               allParts.push({
                 type: `tool-${contentPart.toolName}`,
                 toolCallId: contentPart.toolCallId,
                 state: "output-error",
                 input: undefined,
-                errorText: message.error,
+                errorText: errorText ?? "Unknown error",
                 callProviderMetadata: message.providerMetadata,
               } satisfies ToolUIPart<TOOLS>);
             } else {
@@ -505,8 +560,70 @@ function createAssistantUIMessage<
           }
           break;
         }
+        case "tool-approval-request": {
+          // Find the matching tool call
+          const typedPart = contentPart as {
+            toolCallId: string;
+            approvalId: string;
+          };
+          const toolCallPart = allParts.find(
+            (part) =>
+              "toolCallId" in part && part.toolCallId === typedPart.toolCallId,
+          ) as ToolUIPart | undefined;
+
+          if (toolCallPart) {
+            toolCallPart.state = "approval-requested";
+            (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+              id: typedPart.approvalId,
+            };
+          } else {
+            console.warn(
+              "Tool approval request without preceding tool call",
+              contentPart,
+            );
+          }
+          break;
+        }
+        case "tool-approval-response": {
+          // Find the tool call that has this approval by matching approval.id
+          const typedPart = contentPart as {
+            approvalId: string;
+            approved: boolean;
+            reason?: string;
+          };
+          const toolCallPart = allParts.find(
+            (part) =>
+              "approval" in part &&
+              (part as ToolUIPart & { approval?: { id: string } }).approval
+                ?.id === typedPart.approvalId,
+          ) as ToolUIPart | undefined;
+
+          if (toolCallPart) {
+            if (typedPart.approved) {
+              toolCallPart.state = "approval-responded";
+              (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+                id: typedPart.approvalId,
+                approved: true,
+                reason: typedPart.reason,
+              };
+            } else {
+              toolCallPart.state = "output-denied";
+              (toolCallPart as ToolUIPart & { approval?: object }).approval = {
+                id: typedPart.approvalId,
+                approved: false,
+                reason: typedPart.reason,
+              };
+            }
+          } else {
+            console.warn(
+              "Tool approval response without matching approval request",
+              contentPart,
+            );
+          }
+          break;
+        }
         default: {
-          const maybeSource = contentPart as SourcePart;
+          const maybeSource = contentPart as unknown as SourcePart;
           if (maybeSource.type === "source") {
             allParts.push(toSourcePart(maybeSource));
           } else {
@@ -583,11 +700,12 @@ export function combineUIMessages(messages: UIMessage[]): UIMessage[] {
       const previousPartIndex = newParts.findIndex(
         (p) => getToolCallId(p) === toolCallId,
       );
-      const previousPart = newParts.splice(previousPartIndex, 1)[0];
-      if (!previousPart) {
+      if (previousPartIndex === -1) {
+        // Tool call not found in previous parts, add it as new
         newParts.push(part);
         continue;
       }
+      const previousPart = newParts.splice(previousPartIndex, 1)[0];
       newParts.push(mergeParts(previousPart, part));
     }
     acc.push({