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

package/src/mapping.test.ts

@@ -2,18 +2,22 @@ import { describe, test, expect } from "vitest";
 import {
   guessMimeType,
   serializeDataOrUrl,
-  deserializeUrl,
+  toModelMessageDataOrUrl,
   serializeMessage,
-  deserializeMessage,
+  toModelMessage,
   serializeContent,
+  toModelMessageContent,
+  mergeApprovalResponseMessages,
 } from "./mapping.js";
 import { api } from "./component/_generated/api.js";
 import type { AgentComponent, ActionCtx } from "./client/types.js";
-import { vMessage } from "./validators.js";
+import { vMessage, vToolResultPart } from "./validators.js";
 import fs from "fs";
 import path from "path";
 import type { SerializedContent } from "./mapping.js";
 import { validate } from "convex-helpers/validators";
+import type { ToolResultPart } from "ai";
+import type { Infer } from "convex/values";
 
 const testAssetsDir = path.join(__dirname, "../test-assets");
 const testFiles = [
@@ -54,8 +58,8 @@ describe("mapping", () => {
     const ser = serializeDataOrUrl(arr);
     expect(ser).toBeInstanceOf(ArrayBuffer);
     expect(new Uint8Array(ser as ArrayBuffer)).toEqual(arr);
-    // deserializeUrl should return the same ArrayBuffer
-    const deser = deserializeUrl(ser);
+    // toModelMessageDataOrUrl should return the same ArrayBuffer
+    const deser = toModelMessageDataOrUrl(ser);
     expect(deser).toBeInstanceOf(ArrayBuffer);
     expect(new Uint8Array(deser as ArrayBuffer)).toEqual(arr);
   });
@@ -80,10 +84,56 @@ describe("mapping", () => {
     const { message: ser } = await serializeMessage(ctx, component, message);
     // Use is for type validation
     expect(validate(vMessage, ser)).toBeTruthy();
-    const round = deserializeMessage(ser);
+    const round = toModelMessage(ser);
     expect(round).toEqual(message);
   });
 
+  test("tool output round-trips", async () => {
+    const toolResult = {
+      type: "tool-result" as const,
+      toolCallId: "tool-call-id",
+      toolName: "tool-name",
+      output: {
+        type: "text",
+        value: "hello world",
+      },
+    } satisfies ToolResultPart;
+    const [result] = toModelMessageContent([toolResult]);
+    expect(result).toMatchObject(toolResult);
+    const {
+      content: [roundtrip],
+    } = await serializeContent({} as ActionCtx, {} as AgentComponent, [
+      result as ToolResultPart,
+    ]);
+    expect(roundtrip).toMatchObject(toolResult);
+  });
+
+  test("tool results get normalized to output", async () => {
+    const toolResult = {
+      type: "tool-result" as const,
+      toolCallId: "tool-call-id",
+      toolName: "tool-name",
+      result: "hello world",
+    } satisfies Infer<typeof vToolResultPart>;
+    const expected = {
+      type: "tool-result",
+      toolCallId: "tool-call-id",
+      toolName: "tool-name",
+      output: {
+        type: "text",
+        value: "hello world",
+      },
+    };
+    const [deserialized] = toModelMessageContent([toolResult]);
+    expect(deserialized).toMatchObject(expected);
+    const {
+      content: [serialized],
+    } = await serializeContent({} as ActionCtx, {} as AgentComponent, [
+      toolResult,
+    ]);
+    expect(serialized).toMatchObject(expected);
+  });
+
   test("saving files returns fileIds when too big", async () => {
     // Make a big file
     const bigArr = new Uint8Array(1024 * 65).fill(1);
@@ -160,4 +210,128 @@ describe("mapping", () => {
     const { fileIds } = await serializeContent(ctx, component, content);
     expect(fileIds).toBeUndefined();
   });
+
+  test("tool-approval-request is preserved after serialization", async () => {
+    const approvalRequest = {
+      type: "tool-approval-request" as const,
+      approvalId: "approval-123",
+      toolCallId: "tool-call-456",
+    };
+    const { content } = await serializeContent(
+      {} as ActionCtx,
+      {} as AgentComponent,
+      [approvalRequest],
+    );
+    expect(content).toHaveLength(1);
+    expect((content as unknown[])[0]).toMatchObject(approvalRequest);
+  });
+
+  test("tool-approval-response with approved: true is preserved", async () => {
+    const approvalResponse = {
+      type: "tool-approval-response" as const,
+      approvalId: "approval-123",
+      approved: true,
+      reason: "User approved",
+    };
+    const { content } = await serializeContent(
+      {} as ActionCtx,
+      {} as AgentComponent,
+      [approvalResponse],
+    );
+    expect(content).toHaveLength(1);
+    expect((content as unknown[])[0]).toMatchObject(approvalResponse);
+  });
+
+  test("tool-approval-response with approved: false is preserved", async () => {
+    const approvalResponse = {
+      type: "tool-approval-response" as const,
+      approvalId: "approval-123",
+      approved: false,
+      reason: "User denied",
+      providerExecuted: false,
+    };
+    const { content } = await serializeContent(
+      {} as ActionCtx,
+      {} as AgentComponent,
+      [approvalResponse],
+    );
+    expect(content).toHaveLength(1);
+    expect((content as unknown[])[0]).toMatchObject(approvalResponse);
+  });
+
+  test("mergeApprovalResponseMessages merges consecutive tool approval messages", () => {
+    const messages = [
+      { role: "user" as const, content: "hello" },
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
+          { type: "tool-call", toolCallId: "tc2", toolName: "b", input: {} },
+          { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
+          { type: "tool-approval-request", approvalId: "ap2", toolCallId: "tc2" },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap1", approved: true },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap2", approved: false, reason: "denied" },
+        ],
+      },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    expect(merged).toHaveLength(3); // user, assistant, single tool
+    expect(merged[2].role).toBe("tool");
+    const toolContent = merged[2].content as Array<{ type: string; approvalId: string }>;
+    expect(toolContent).toHaveLength(2);
+    expect(toolContent[0].approvalId).toBe("ap1");
+    expect(toolContent[1].approvalId).toBe("ap2");
+  });
+
+  test("mergeApprovalResponseMessages does not mutate original message content arrays", () => {
+    const msg1Content = [
+      { type: "tool-approval-response", approvalId: "ap1", approved: true },
+    ];
+    const msg2Content = [
+      { type: "tool-approval-response", approvalId: "ap2", approved: false, reason: "denied" },
+    ];
+    const messages = [
+      { role: "tool" as const, content: msg1Content },
+      { role: "tool" as const, content: msg2Content },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    // Merged result should combine both
+    expect(merged).toHaveLength(1);
+    expect((merged[0].content as any[]).length).toBe(2);
+    // Original arrays must be untouched
+    expect(msg1Content).toHaveLength(1);
+    expect(msg2Content).toHaveLength(1);
+  });
+
+  test("mergeApprovalResponseMessages does not merge non-approval tool messages", () => {
+    const messages = [
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-result", toolCallId: "tc1", toolName: "a", output: { type: "text", value: "ok" } },
+        ],
+      },
+      {
+        role: "tool" as const,
+        content: [
+          { type: "tool-approval-response", approvalId: "ap1", approved: true },
+        ],
+      },
+    ] as any;
+
+    const merged = mergeApprovalResponseMessages(messages);
+    expect(merged).toHaveLength(2); // not merged since first has tool-result
+  });
 });