@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/cli/commands/__tests__/domain-status.test.ts

@@ -16,9 +16,7 @@ import { Command } from "commander";
 // Mock state
 // ---------------------------------------------------------------------------
 
-let mockIpcCallFn = mock(() =>
-  Promise.resolve({ ok: true, result: {} }),
-);
+let mockIpcCallFn = mock(() => Promise.resolve({ ok: true, result: {} }));
 
 // ---------------------------------------------------------------------------
 // Mocks — must be declared before importing the module under test
@@ -142,7 +140,12 @@ describe("assistant domain status", () => {
   test("--json outputs structured response", async () => {
     mockDomainStatusWithVerification();
 
-    const output = await runDomainCommand("domain", "--json", "status", "becky");
+    const output = await runDomainCommand(
+      "domain",
+      "--json",
+      "status",
+      "becky",
+    );
 
     const parsed = JSON.parse(output.trim());
     expect(parsed.domain.domain).toBe("becky.vellum.me");
@@ -171,7 +174,12 @@ describe("assistant domain status", () => {
       }),
     ) as unknown as typeof mockIpcCallFn;
 
-    const output = await runDomainCommand("domain", "--json", "status", "becky");
+    const output = await runDomainCommand(
+      "domain",
+      "--json",
+      "status",
+      "becky",
+    );
 
     expect(process.exitCode).not.toBe(0);
     const parsed = JSON.parse(output.trim());

package/src/cli/commands/__tests__/email-attachment.test.ts

@@ -13,7 +13,9 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Mock state
 // ---------------------------------------------------------------------------
 
-let mockIpcCallFn: any = mock(() => Promise.resolve({ ok: true, result: { results: [] } }));
+let mockIpcCallFn: any = mock(() =>
+  Promise.resolve({ ok: true, result: { results: [] } }),
+);
 let mockIpcCallStreamFn: any = mock(() =>
   Promise.resolve({ ok: false, error: "not used" }),
 );
@@ -23,7 +25,8 @@ let mockIpcCallStreamFn: any = mock(() =>
 // ---------------------------------------------------------------------------
 
 mock.module("../../../ipc/cli-client.js", () => ({
-  cliIpcCall: (...args: Parameters<typeof mockIpcCallFn>) => mockIpcCallFn(...args),
+  cliIpcCall: (...args: Parameters<typeof mockIpcCallFn>) =>
+    mockIpcCallFn(...args),
   cliIpcCallStream: (...args: Parameters<typeof mockIpcCallStreamFn>) =>
     mockIpcCallStreamFn(...args),
   exitFromIpcResult: mock((r: { error?: string; statusCode?: number }) => {
@@ -69,11 +72,18 @@ function makeMockStream(chunks: Uint8Array[]): {
 } {
   const body = new ReadableStream<Uint8Array>({
     start(ctrl) {
-      for (const chunk of chunks) ctrl.enqueue(chunk);
+      for (const chunk of chunks) {
+        ctrl.enqueue(chunk);
+      }
       ctrl.close();
     },
   });
-  return { ok: true, headers: { "x-filename": "test.pdf" }, body, abort: () => {} };
+  return {
+    ok: true,
+    headers: { "x-filename": "test.pdf" },
+    body,
+    abort: () => {},
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -86,7 +96,10 @@ beforeEach(() => {
   process.exitCode = 0;
   captured.length = 0;
 
-  tmpDir = join(tmpdir(), `email-att-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  tmpDir = join(
+    tmpdir(),
+    `email-att-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
   mkdirSync(tmpDir, { recursive: true });
 
   // Default: list returns two attachments
@@ -117,16 +130,16 @@ beforeEach(() => {
   );
 
   mockIpcCallStreamFn = mock(() =>
-    Promise.resolve(
-      makeMockStream([new Uint8Array([1, 2, 3])]),
-    ),
+    Promise.resolve(makeMockStream([new Uint8Array([1, 2, 3])])),
   );
 });
 
 afterEach(() => {
   process.exitCode = 0;
   captured.length = 0;
-  if (existsSync(tmpDir)) rmSync(tmpDir, { recursive: true });
+  if (existsSync(tmpDir)) {
+    rmSync(tmpDir, { recursive: true });
+  }
 });
 
 // ---------------------------------------------------------------------------
@@ -148,7 +161,13 @@ async function runAttachment(...args: string[]): Promise<string> {
     const program = new Command();
     program.exitOverride();
     registerEmailCommand(program);
-    await program.parseAsync(["node", "assistant", "email", "attachment", ...args]);
+    await program.parseAsync([
+      "node",
+      "assistant",
+      "email",
+      "attachment",
+      ...args,
+    ]);
   } catch {
     // exitOverride throws on --help etc; ignore
   } finally {
@@ -167,7 +186,10 @@ describe("email attachment (IPC)", () => {
     await runAttachment("msg_1", "--list");
 
     expect(mockIpcCallFn.mock.calls.length).toBeGreaterThan(0);
-    const [method, params] = mockIpcCallFn.mock.calls[0] as unknown as [string, { queryParams: Record<string, unknown> }];
+    const [method, params] = mockIpcCallFn.mock.calls[0] as unknown as [
+      string,
+      { queryParams: Record<string, unknown> },
+    ];
     expect(method).toBe("email_attachment_list");
     expect(params.queryParams.messageId).toBe("msg_1");
   });
@@ -206,7 +228,15 @@ describe("email attachment (IPC)", () => {
       const program = new Command();
       program.exitOverride();
       registerEmailCommand(program);
-      await program.parseAsync(["node", "assistant", "email", "--json", "attachment", "msg_1", "--list"]);
+      await program.parseAsync([
+        "node",
+        "assistant",
+        "email",
+        "--json",
+        "attachment",
+        "msg_1",
+        "--list",
+      ]);
     } finally {
       process.stdout.write = origWrite;
     }
@@ -232,12 +262,18 @@ describe("email attachment (IPC)", () => {
     await runAttachment("msg_1", "att-001", "-o", tmpDir);
 
     // The list call should come first
-    const listCall = mockIpcCallFn.mock.calls[0] as unknown as [string, { queryParams: Record<string, unknown> }];
+    const listCall = mockIpcCallFn.mock.calls[0] as unknown as [
+      string,
+      { queryParams: Record<string, unknown> },
+    ];
     expect(listCall[0]).toBe("email_attachment_list");
     expect(listCall[1].queryParams.messageId).toBe("msg_1");
 
     // Stream call should use the correct attachmentId and messageId
-    const streamCall = mockIpcCallStreamFn.mock.calls[0] as unknown as [string, { queryParams: Record<string, unknown> }];
+    const streamCall = mockIpcCallStreamFn.mock.calls[0] as unknown as [
+      string,
+      { queryParams: Record<string, unknown> },
+    ];
     expect(streamCall[0]).toBe("email_attachment_get");
     expect(streamCall[1].queryParams.attachmentId).toBe("att-001");
     expect(streamCall[1].queryParams.messageId).toBe("msg_1");
@@ -289,14 +325,20 @@ describe("email attachment (IPC)", () => {
     await runAttachment("msg_1", "--all", "-o", tmpDir);
 
     // First IPC call: list
-    const listCall = mockIpcCallFn.mock.calls[0] as unknown as [string, Record<string, unknown>];
+    const listCall = mockIpcCallFn.mock.calls[0] as unknown as [
+      string,
+      Record<string, unknown>,
+    ];
     expect(listCall[0]).toBe("email_attachment_list");
 
     // Two stream calls — one per attachment
     expect(mockIpcCallStreamFn.mock.calls.length).toBe(2);
-    const ids = (mockIpcCallStreamFn.mock.calls as unknown as [string, { queryParams: Record<string, unknown> }][]).map(
-      ([, p]) => p.queryParams.attachmentId,
-    );
+    const ids = (
+      mockIpcCallStreamFn.mock.calls as unknown as [
+        string,
+        { queryParams: Record<string, unknown> },
+      ][]
+    ).map(([, p]) => p.queryParams.attachmentId);
     expect(ids).toContain("att-001");
     expect(ids).toContain("att-002");
 
@@ -396,4 +438,4 @@ describe("email attachment (IPC)", () => {
     expect(out).toContain("2.4 MB");
     expect(process.exitCode).toBe(0);
   });
-});  
+});

package/src/cli/commands/__tests__/email-core.test.ts

@@ -18,9 +18,7 @@ import { Command } from "commander";
 // Mock state
 // ---------------------------------------------------------------------------
 
-let mockIpcCallFn = mock(() =>
-  Promise.resolve({ ok: true, result: {} }),
-);
+let mockIpcCallFn = mock(() => Promise.resolve({ ok: true, result: {} }));
 
 // ---------------------------------------------------------------------------
 // Mocks — must be declared before importing the module under test
@@ -95,15 +93,24 @@ describe("email register", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
-    await program.parseAsync(["node", "assistant", "email", "register", "mybot"]);
+    await program.parseAsync([
+      "node",
+      "assistant",
+      "email",
+      "register",
+      "mybot",
+    ]);
 
-    expect(mockIpcCallFn).toHaveBeenCalledWith("email_register", { body: { username: "mybot" } });
+    expect(mockIpcCallFn).toHaveBeenCalledWith("email_register", {
+      body: { username: "mybot" },
+    });
   });
 
   test("--json outputs structured response", async () => {
@@ -125,7 +132,8 @@ describe("email register", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const stdoutChunks: string[] = [];
     const origWrite = process.stdout.write.bind(process.stdout);
@@ -142,7 +150,14 @@ describe("email register", () => {
         writeOut: (str: string) => stdoutChunks.push(str),
       });
       registerEmailCmd(program);
-      await program.parseAsync(["node", "assistant", "email", "--json", "register", "mybot"]);
+      await program.parseAsync([
+        "node",
+        "assistant",
+        "email",
+        "--json",
+        "register",
+        "mybot",
+      ]);
     } catch {
       // commander may throw on exitOverride
     } finally {
@@ -175,7 +190,8 @@ describe("email register", () => {
       exitFromIpcResult: exitFromIpcResultMock,
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
@@ -183,7 +199,13 @@ describe("email register", () => {
     registerEmailCmd(program);
 
     try {
-      await program.parseAsync(["node", "assistant", "email", "register", "mybot"]);
+      await program.parseAsync([
+        "node",
+        "assistant",
+        "email",
+        "register",
+        "mybot",
+      ]);
     } catch {
       // may throw
     }
@@ -215,17 +237,23 @@ describe("email send", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant",
-      "email", "send", "user@example.com",
-      "-s", "Hello",
-      "-b", "Hi there",
+      "node",
+      "assistant",
+      "email",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Hi there",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith(
@@ -258,19 +286,27 @@ describe("email send", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant",
-      "email", "send", "user@example.com",
-      "--cc", "cc@example.com",
-      "--bcc", "bcc@example.com",
-      "-s", "Test",
-      "-b", "Body",
+      "node",
+      "assistant",
+      "email",
+      "send",
+      "user@example.com",
+      "--cc",
+      "cc@example.com",
+      "--bcc",
+      "bcc@example.com",
+      "-s",
+      "Test",
+      "-b",
+      "Body",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith(
@@ -302,23 +338,32 @@ describe("email send", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant",
-      "email", "send", "user@example.com",
-      "-s", "Re: Test",
-      "-b", "Thanks!",
-      "--reply-to", "msg_abc",
+      "node",
+      "assistant",
+      "email",
+      "send",
+      "user@example.com",
+      "-s",
+      "Re: Test",
+      "-b",
+      "Thanks!",
+      "--reply-to",
+      "msg_abc",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith(
       "email_send",
-      expect.objectContaining({ body: expect.objectContaining({ reply_to: "msg_abc" }) }),
+      expect.objectContaining({
+        body: expect.objectContaining({ reply_to: "msg_abc" }),
+      }),
     );
   });
 });
@@ -346,7 +391,8 @@ describe("email list", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
@@ -354,7 +400,9 @@ describe("email list", () => {
     registerEmailCmd(program);
     await program.parseAsync(["node", "assistant", "email", "list"]);
 
-    expect(mockIpcCallFn).toHaveBeenCalledWith("email_list", { queryParams: { limit: "20" } });
+    expect(mockIpcCallFn).toHaveBeenCalledWith("email_list", {
+      queryParams: { limit: "20" },
+    });
   });
 
   test("passes direction param when --direction given", async () => {
@@ -375,19 +423,27 @@ describe("email list", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant", "email", "list", "--direction", "inbound",
+      "node",
+      "assistant",
+      "email",
+      "list",
+      "--direction",
+      "inbound",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith(
       "email_list",
-      expect.objectContaining({ queryParams: expect.objectContaining({ direction: "inbound" }) }),
+      expect.objectContaining({
+        queryParams: expect.objectContaining({ direction: "inbound" }),
+      }),
     );
   });
 
@@ -409,21 +465,32 @@ describe("email list", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant", "email", "list",
-      "--limit", "5",
-      "--since", "2026-01-01",
+      "node",
+      "assistant",
+      "email",
+      "list",
+      "--limit",
+      "5",
+      "--since",
+      "2026-01-01",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith(
       "email_list",
-      expect.objectContaining({ queryParams: expect.objectContaining({ limit: "5", since: "2026-01-01" }) }),
+      expect.objectContaining({
+        queryParams: expect.objectContaining({
+          limit: "5",
+          since: "2026-01-01",
+        }),
+      }),
     );
   });
 });
@@ -462,7 +529,8 @@ describe("email status", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
@@ -497,14 +565,19 @@ describe("email unregister", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const program = new Command();
     program.exitOverride();
     program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
     registerEmailCmd(program);
     await program.parseAsync([
-      "node", "assistant", "email", "unregister", "--confirm",
+      "node",
+      "assistant",
+      "email",
+      "unregister",
+      "--confirm",
     ]);
 
     expect(mockIpcCallFn).toHaveBeenCalledWith("email_unregister", {});
@@ -545,7 +618,8 @@ describe("email download", () => {
       }),
     }));
 
-    const { registerEmailCommand: registerEmailCmd } = await import("../email.js");
+    const { registerEmailCommand: registerEmailCmd } =
+      await import("../email.js");
 
     const stdoutChunks: string[] = [];
     const origWrite = process.stdout.write.bind(process.stdout);
@@ -563,7 +637,11 @@ describe("email download", () => {
       });
       registerEmailCmd(program);
       await program.parseAsync([
-        "node", "assistant", "email", "download", "msg_1",
+        "node",
+        "assistant",
+        "email",
+        "download",
+        "msg_1",
       ]);
     } catch {
       // may throw
@@ -571,9 +649,8 @@ describe("email download", () => {
       process.stdout.write = origWrite;
     }
 
-    expect(mockIpcCallFn).toHaveBeenCalledWith(
-      "email_download",
-      { queryParams: { messageId: "msg_1" } },
-    );
+    expect(mockIpcCallFn).toHaveBeenCalledWith("email_download", {
+      queryParams: { messageId: "msg_1" },
+    });
   });
-});    
+});

package/src/cli/commands/__tests__/gateway.test.ts

@@ -47,7 +47,9 @@ mock.module("../../../ipc/cli-client.js", () => ({
   },
   exitFromIpcResult: (r: { error?: string }) => {
     process.exitCode = 1;
-    if (r.error) process.stderr.write(r.error);
+    if (r.error) {
+      process.stderr.write(r.error);
+    }
   },
 }));
 
@@ -99,7 +101,9 @@ async function runCommand(
     registerGatewayCommand(program);
     await program.parseAsync(["node", "assistant", ...args]);
   } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
   } finally {
     process.stdout.write = originalStdoutWrite;
   }

package/src/cli/commands/__tests__/image-generation.test.ts

@@ -39,7 +39,8 @@ mock.module("../../../util/logger.js", () => ({
 // We can set outputDir via --output-dir to avoid needing to mock os.tmpdir
 const TEST_OUTPUT_DIR = "/tmp/test-image-gen";
 
-const { registerImageGenerationCommand } = await import("../image-generation.js");
+const { registerImageGenerationCommand } =
+  await import("../image-generation.js");
 
 function buildProgram(): Command {
   const program = new Command();
@@ -110,7 +111,9 @@ describe("image-generation generate", () => {
       "--output-dir",
       TEST_OUTPUT_DIR,
     ]);
-    expect((mockCalls[0][1].body as Record<string, unknown>).model).toBe("gpt-image-2");
+    expect((mockCalls[0][1].body as Record<string, unknown>).model).toBe(
+      "gpt-image-2",
+    );
   });
 
   it("passes variants", async () => {

package/src/cli/commands/__tests__/inference-send.test.ts

@@ -132,7 +132,9 @@ async function runCommand(
     registerInferenceCommand(program);
     await program.parseAsync(["node", "assistant", ...args]);
   } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
   } finally {
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;

package/src/cli/commands/__tests__/skills.test.ts

@@ -104,7 +104,9 @@ async function runCommand(
     registerSkillsCommand(program);
     await program.parseAsync(["node", "assistant", ...args]);
   } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
   } finally {
     process.stdout.write = originalStdoutWrite;
     console.log = originalConsoleLog;

package/src/cli/commands/__tests__/status.test.ts

@@ -21,7 +21,12 @@ const DAEMON_UNREACHABLE_ERROR =
   "Run `assistant status` to check, or `assistant gateway start` to start it.";
 
 let ipcCalls: Array<{ method: string }> = [];
-let mockResponse: { ok: boolean; result?: unknown; error?: string; statusCode?: number } = {
+let mockResponse: {
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+  statusCode?: number;
+} = {
   ok: false,
   error: DAEMON_UNREACHABLE_ERROR,
 };
@@ -201,7 +206,11 @@ describe("status command — daemon unreachable (ENOENT/ECONNREFUSED)", () => {
 
 describe("status command — non-connection IPC failures", () => {
   test("exits non-zero when daemon returns an internal error", async () => {
-    mockResponse = { ok: false, error: "Internal server error", statusCode: 500 };
+    mockResponse = {
+      ok: false,
+      error: "Internal server error",
+      statusCode: 500,
+    };
 
     const { exitCode } = await runStatusCommand();
 
@@ -217,7 +226,11 @@ describe("status command — non-connection IPC failures", () => {
   });
 
   test("prints the error message to stderr for non-connection failures", async () => {
-    mockResponse = { ok: false, error: "Internal server error", statusCode: 500 };
+    mockResponse = {
+      ok: false,
+      error: "Internal server error",
+      statusCode: 500,
+    };
 
     const { stderr } = await runStatusCommand();