@convex-dev/agent 0.6.3 → 0.7.0-alpha.0

package/src/mapping.test.ts

@@ -1,402 +0,0 @@
-import { describe, test, expect, vi } from "vitest";
-import {
-  guessMimeType,
-  serializeDataOrUrl,
-  toModelMessageDataOrUrl,
-  serializeMessage,
-  toModelMessage,
-  serializeContent,
-  toModelMessageContent,
-  autoDenyUnresolvedApprovals,
-} from "./mapping.js";
-import { api } from "./component/_generated/api.js";
-import type { AgentComponent, ActionCtx } from "./client/types.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 = [
-  "book.svg",
-  "bump.jpeg",
-  "stack.png",
-  "favicon.ico",
-  "convex-logo.svg",
-  "stack-light@3x.webp",
-];
-
-function fileToArrayBuffer(filePath: string): ArrayBuffer {
-  const buf = fs.readFileSync(filePath);
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-}
-
-describe("mapping", () => {
-  test("infers correct mimeType for all test-assets", () => {
-    const expected: { [key: string]: string } = {
-      "book.svg": "image/svg+xml", // <svg
-      "bump.jpeg": "image/jpeg",
-      "stack.png": "image/png",
-      "favicon.ico": "application/octet-stream", // fallback for ico
-      "convex-logo.svg": "image/svg+xml", // <?xm
-      "stack-light@3x.webp": "image/webp",
-      "cat.gif": "image/gif",
-    };
-    for (const file of testFiles) {
-      const ab = fileToArrayBuffer(path.join(testAssetsDir, file));
-      const mime = guessMimeType(ab);
-      expect(mime).toBe(expected[file]);
-    }
-  });
-
-  test("turns Uint8Array into ArrayBuffer and round-trips", () => {
-    const arr = new Uint8Array([1, 2, 3, 4, 5]);
-    // serializeDataOrUrl should return the same ArrayBuffer
-    const ser = serializeDataOrUrl(arr);
-    expect(ser).toBeInstanceOf(ArrayBuffer);
-    expect(new Uint8Array(ser as ArrayBuffer)).toEqual(arr);
-    // toModelMessageDataOrUrl should return the same ArrayBuffer
-    const deser = toModelMessageDataOrUrl(ser);
-    expect(deser).toBeInstanceOf(ArrayBuffer);
-    expect(new Uint8Array(deser as ArrayBuffer)).toEqual(arr);
-  });
-
-  test("round-trip serialize/deserialize message", async () => {
-    const message = {
-      role: "user" as const,
-      content: "hello world",
-      providerOptions: {},
-    };
-    // Fake ctx and component
-    const ctx = {
-      runAction: async () => undefined,
-      runMutation: async () => undefined,
-      storage: {
-        store: async () => "storageId",
-        getUrl: async () => "https://example.com/file",
-        delete: async () => undefined,
-      },
-    } as unknown as ActionCtx;
-    const component = api as unknown as AgentComponent;
-    const { message: ser } = await serializeMessage(ctx, component, message);
-    // Use is for type validation
-    expect(validate(vMessage, ser)).toBeTruthy();
-    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);
-    const ab = bigArr.buffer.slice(
-      bigArr.byteOffset,
-      bigArr.byteOffset + bigArr.byteLength,
-    );
-    let called = false;
-    const ctx = {
-      runAction: async () => undefined,
-      runMutation: async (_fn: unknown, _args: unknown) => {
-        called = true;
-        return { fileId: "file-123", storageId: "storage-123" };
-      },
-      storage: {
-        store: async () => "storageId",
-        getUrl: async () => "https://example.com/file",
-        delete: async () => undefined,
-      },
-    } as unknown as ActionCtx;
-    const component = api as unknown as AgentComponent;
-    const content = [
-      {
-        type: "file" as const,
-        data: ab,
-        filename: "bigfile.bin",
-        mimeType: "application/octet-stream",
-        providerOptions: {},
-      },
-    ];
-    const { content: ser, fileIds } = await serializeContent(
-      ctx,
-      component,
-      content,
-    );
-    expect(called).toBe(true);
-    expect(fileIds).toEqual(["file-123"]);
-    // Should have replaced data with a URL
-    const serArr = ser as SerializedContent;
-    expect(typeof (serArr as { data: unknown }[])[0].data).toBe("string");
-    expect((serArr as { data: unknown }[])[0].data as string).toMatch(
-      /^https?:\/\//,
-    );
-  });
-
-  test("sanity: fileIds are not returned for small files", async () => {
-    const arr = new Uint8Array([1, 2, 3, 4, 5]);
-    const ab = arr.buffer.slice(
-      arr.byteOffset,
-      arr.byteOffset + arr.byteLength,
-    );
-    const ctx = {
-      runAction: async () => undefined,
-      runMutation: async () => ({
-        fileId: "file-123",
-        storageId: "storage-123",
-      }),
-      storage: {
-        store: async () => "storageId",
-        getUrl: async () => "https://example.com/file",
-        delete: async () => undefined,
-      },
-    } as unknown as ActionCtx;
-    const component = api as unknown as AgentComponent;
-    const content = [
-      {
-        type: "file" as const,
-        data: ab,
-        filename: "smallfile.bin",
-        mimeType: "application/octet-stream",
-        providerOptions: {},
-      },
-    ];
-    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);
-  });
-
-  describe("autoDenyUnresolvedApprovals", () => {
-    test("returns messages unchanged when no unresolved approvals", () => {
-      const messages = [
-        { role: "user" as const, content: "hello" },
-        {
-          role: "assistant" as const,
-          content: [
-            { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
-            { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
-          ],
-        },
-        {
-          role: "tool" as const,
-          content: [
-            { type: "tool-approval-response", approvalId: "ap1", approved: true },
-          ],
-        },
-      ] as any;
-
-      const result = autoDenyUnresolvedApprovals(messages);
-      expect(result).toBe(messages); // same reference, no changes
-    });
-
-    test("injects synthetic denial for a single unresolved approval", () => {
-      const messages = [
-        { role: "user" as const, content: "hello" },
-        {
-          role: "assistant" as const,
-          content: [
-            { type: "tool-call", toolCallId: "tc1", toolName: "a", input: {} },
-            { type: "tool-approval-request", approvalId: "ap1", toolCallId: "tc1" },
-          ],
-        },
-        { role: "user" as const, content: "new message" },
-      ] as any;
-
-      const result = autoDenyUnresolvedApprovals(messages);
-      expect(result).toHaveLength(4); // original 3 + 1 synthetic tool message
-      // Synthetic denial should be inserted right after the assistant message (index 1)
-      expect(result[2].role).toBe("tool");
-      const denialContent = result[2].content as any[];
-      expect(denialContent).toHaveLength(1);
-      expect(denialContent[0].type).toBe("tool-approval-response");
-      expect(denialContent[0].approvalId).toBe("ap1");
-      expect(denialContent[0].approved).toBe(false);
-      expect(denialContent[0].reason).toBe("auto-denied: new generation started");
-      // The new user message should follow
-      expect(result[3].role).toBe("user");
-      expect(result[3].content).toBe("new message");
-    });
-
-    test("groups multiple unresolved approvals from the same step into a single synthetic message", () => {
-      const messages = [
-        {
-          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" },
-          ],
-        },
-      ] as any;
-
-      const result = autoDenyUnresolvedApprovals(messages);
-      expect(result).toHaveLength(2); // assistant + 1 synthetic tool message
-      expect(result[1].role).toBe("tool");
-      const denialContent = result[1].content as any[];
-      expect(denialContent).toHaveLength(2);
-      expect(denialContent[0].approvalId).toBe("ap1");
-      expect(denialContent[0].approved).toBe(false);
-      expect(denialContent[1].approvalId).toBe("ap2");
-      expect(denialContent[1].approved).toBe(false);
-    });
-
-    test("only auto-denies unresolved approvals, leaves resolved ones alone", () => {
-      const messages = [
-        {
-          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: "user" as const, content: "next question" },
-      ] as any;
-
-      const result = autoDenyUnresolvedApprovals(messages);
-      // Should inject a denial for ap2 (unresolved) after the assistant message
-      expect(result).toHaveLength(4); // assistant + existing tool + synthetic denial + user
-      // The synthetic denial is inserted after the assistant (index 0)
-      expect(result[0].role).toBe("assistant");
-      expect(result[1].role).toBe("tool"); // synthetic denial for ap2
-      const denialContent = result[1].content as any[];
-      expect(denialContent).toHaveLength(1);
-      expect(denialContent[0].approvalId).toBe("ap2");
-      expect(denialContent[0].approved).toBe(false);
-      // Original tool message (ap1 response) follows
-      expect(result[2].role).toBe("tool");
-      const originalToolContent = result[2].content as any[];
-      expect(originalToolContent[0].approvalId).toBe("ap1");
-      expect(originalToolContent[0].approved).toBe(true);
-      // User message last
-      expect(result[3].role).toBe("user");
-    });
-
-    test("emits console.warn for each auto-denied approval", () => {
-      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-      const messages = [
-        {
-          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" },
-          ],
-        },
-      ] as any;
-
-      autoDenyUnresolvedApprovals(messages);
-
-      expect(warnSpy).toHaveBeenCalledTimes(2);
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("ap1"),
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("ap2"),
-      );
-      warnSpy.mockRestore();
-    });
-  });
-});