@vellumai/assistant 0.5.16 → 0.6.1

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

@@ -0,0 +1,192 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  deleteSecureKeyAsync,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+const SAMPLE_MESSAGES = [
+  {
+    id: "msg-001",
+    direction: "inbound",
+    from_address: "user@example.com",
+    to_addresses: ["mybot@vellum.me"],
+    subject: "Hello bot",
+    created_at: "2026-04-05T12:00:00Z",
+  },
+  {
+    id: "msg-002",
+    direction: "outbound",
+    from_address: "mybot@vellum.me",
+    to_addresses: ["user@example.com"],
+    subject: "Re: Hello bot",
+    created_at: "2026-04-05T12:01:00Z",
+  },
+];
+
+function mockListEmails(
+  results = SAMPLE_MESSAGES,
+  count?: number,
+  status = 200,
+): void {
+  mockFetch(
+    "/emails/",
+    {},
+    { body: { results, count: count ?? results.length }, status },
+  );
+}
+
+let savedCesUrl: string | undefined;
+let savedContainerized: string | undefined;
+
+beforeEach(async () => {
+  process.exitCode = 0;
+
+  savedCesUrl = process.env.CES_CREDENTIAL_URL;
+  savedContainerized = process.env.IS_CONTAINERIZED;
+  delete process.env.CES_CREDENTIAL_URL;
+  delete process.env.IS_CONTAINERIZED;
+
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+
+  if (savedCesUrl !== undefined) process.env.CES_CREDENTIAL_URL = savedCesUrl;
+  else delete process.env.CES_CREDENTIAL_URL;
+  if (savedContainerized !== undefined)
+    process.env.IS_CONTAINERIZED = savedContainerized;
+  else delete process.env.IS_CONTAINERIZED;
+});
+
+describe("assistant email list", () => {
+  test("--json returns messages and count", async () => {
+    mockListEmails();
+
+    const output = await runAssistantCommand("email", "--json", "list");
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.results).toHaveLength(2);
+    expect(parsed.count).toBe(2);
+    expect(parsed.results[0].subject).toBe("Hello bot");
+    expect(parsed.results[1].direction).toBe("outbound");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("calls correct URL with no filters", async () => {
+    mockListEmails();
+
+    await runAssistantCommand("email", "--json", "list");
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].path).toContain(`/v1/assistants/${ASSISTANT_ID}/emails/`);
+    // Default limit=20 should be in query string
+    expect(calls[0].path).toContain("limit=20");
+  });
+
+  test("--direction filters by direction", async () => {
+    mockListEmails();
+
+    await runAssistantCommand(
+      "email",
+      "--json",
+      "list",
+      "--direction",
+      "inbound",
+    );
+
+    const calls = getMockFetchCalls();
+    expect(calls[0].path).toContain("direction=inbound");
+  });
+
+  test("--limit sets result count", async () => {
+    mockListEmails();
+
+    await runAssistantCommand("email", "--json", "list", "--limit", "5");
+
+    const calls = getMockFetchCalls();
+    expect(calls[0].path).toContain("limit=5");
+  });
+
+  test("--since filters by date", async () => {
+    mockListEmails();
+
+    await runAssistantCommand(
+      "email",
+      "--json",
+      "list",
+      "--since",
+      "2026-04-01",
+    );
+
+    const calls = getMockFetchCalls();
+    expect(calls[0].path).toContain("since=2026-04-01");
+  });
+
+  test("empty results returns empty array", async () => {
+    mockListEmails([], 0);
+
+    const output = await runAssistantCommand("email", "--json", "list");
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.results).toHaveLength(0);
+    expect(parsed.count).toBe(0);
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("endpoint failure returns error", async () => {
+    mockFetch(
+      "/emails/",
+      {},
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand("email", "--json", "list");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Internal server error");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    await deleteSecureKeyAsync(API_KEY_CREDENTIAL);
+
+    const output = await runAssistantCommand("email", "--json", "list");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand("email", "--json", "list");
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+});

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

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+beforeEach(async () => {
+  process.exitCode = 0;
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+});
+
+describe("assistant email register", () => {
+  test("successful registration calls correct URL and body", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          address: "mybot@vellum.me",
+          created_at: "2026-04-04T21:00:00Z",
+        },
+        status: 201,
+      },
+    );
+
+    await runAssistantCommand("email", "register", "mybot");
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].path).toBe(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/`,
+    );
+    expect(calls[0].init.method).toBe("POST");
+    expect(JSON.parse(calls[0].init.body as string)).toEqual({
+      username: "mybot",
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json outputs structured response", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          address: "support@vellum.me",
+          created_at: "2026-04-04T21:00:00Z",
+        },
+        status: 201,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "support",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.address).toBe("support@vellum.me");
+    expect(parsed.id).toBe("550e8400-e29b-41d4-a716-446655440000");
+    expect(parsed.created_at).toBe("2026-04-04T21:00:00Z");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("duplicate address returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      {
+        body: {
+          assistant_id: ["This assistant already has an email address."],
+        },
+        status: 400,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("already has an email address");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    // Remove the API key so create() returns null
+    _resetBackend();
+    setPlatformAssistantId(undefined);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+
+  test("platform 5xx returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "mybot",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Internal server error");
+  });
+
+  test("username validation error from platform is surfaced", async () => {
+    mockFetch(
+      "/email-addresses/",
+      { method: "POST" },
+      { body: { username: ["Enter a valid value."] }, status: 400 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "register",
+      "invalid username!",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("valid value");
+  });
+});

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

@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getMockFetchCalls,
+  mockFetch,
+  resetMockFetch,
+} from "../../../__tests__/mock-fetch.js";
+import { _setOverridesForTesting } from "../../../config/assistant-feature-flags.js";
+import { setPlatformAssistantId } from "../../../config/env.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import {
+  _resetBackend,
+  setSecureKeyAsync,
+} from "../../../security/secure-keys.js";
+import { runAssistantCommand } from "../../__tests__/run-assistant-command.js";
+
+const ASSISTANT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const ADDRESS_ID = "550e8400-e29b-41d4-a716-446655440000";
+const ADDRESS = "mybot@vellum.me";
+const API_KEY_CREDENTIAL = credentialKey("vellum", "assistant_api_key");
+
+function mockListAddresses(
+  addresses: { id: string; address: string }[] = [
+    { id: ADDRESS_ID, address: ADDRESS },
+  ],
+  status = 200,
+): void {
+  mockFetch("/email-addresses/", {}, { body: { results: addresses }, status });
+}
+
+function mockSendSuccess(deliveryId = "del_abc123", status = 202): void {
+  mockFetch(
+    "/runtime-proxy/email/send/",
+    { method: "POST" },
+    { body: { delivery_id: deliveryId, status: "accepted" }, status },
+  );
+}
+
+beforeEach(async () => {
+  process.exitCode = 0;
+  _resetBackend();
+  resetMockFetch();
+  _setOverridesForTesting({ "email-channel": true });
+  setPlatformAssistantId(ASSISTANT_ID);
+  await setSecureKeyAsync(API_KEY_CREDENTIAL, "test-api-key");
+});
+
+afterEach(() => {
+  resetMockFetch();
+  _setOverridesForTesting({});
+  setPlatformAssistantId(undefined);
+  _resetBackend();
+});
+
+describe("assistant email send", () => {
+  test("successful send with --body and --subject", async () => {
+    mockListAddresses();
+    mockSendSuccess();
+
+    await runAssistantCommand(
+      "email",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Hi there",
+    );
+
+    const calls = getMockFetchCalls();
+    expect(calls).toHaveLength(2);
+
+    // First call: list addresses to resolve "from"
+    expect(calls[0].path).toBe(
+      `/v1/assistants/${ASSISTANT_ID}/email-addresses/`,
+    );
+
+    // Second call: send via runtime proxy
+    expect(calls[1].path).toBe("/v1/runtime-proxy/email/send/");
+    expect(calls[1].init.method).toBe("POST");
+
+    const payload = JSON.parse(calls[1].init.body as string);
+    expect(payload.to).toBe("user@example.com");
+    expect(payload.from_address).toBe(ADDRESS);
+    expect(payload.subject).toBe("Hello");
+    expect(payload.text).toBe("Hi there");
+
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json outputs structured response", async () => {
+    mockListAddresses();
+    mockSendSuccess("del_xyz789");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Test",
+      "-b",
+      "Body",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.delivery_id).toBe("del_xyz789");
+    expect(parsed.status).toBe("accepted");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("no registered address returns error", async () => {
+    mockListAddresses([]);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("No email address registered");
+  });
+
+  test("missing body returns error", async () => {
+    // Force isTTY to true so stdin fallback is skipped
+    const origIsTTY = process.stdin.isTTY;
+    process.stdin.isTTY = true as unknown as boolean;
+
+    mockListAddresses();
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+    );
+
+    process.stdin.isTTY = origIsTTY;
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Email body is required");
+  });
+
+  test("send endpoint failure surfaces error detail", async () => {
+    mockListAddresses();
+    mockFetch(
+      "/runtime-proxy/email/send/",
+      { method: "POST" },
+      {
+        body: { detail: "From address not owned by this assistant." },
+        status: 403,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("not owned by this assistant");
+  });
+
+  test("list addresses failure returns error", async () => {
+    mockFetch(
+      "/email-addresses/",
+      {},
+      { body: { detail: "Internal server error" }, status: 500 },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Failed to list email addresses");
+  });
+
+  test("missing platform credentials returns error", async () => {
+    _resetBackend();
+    setPlatformAssistantId(undefined);
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Platform credentials not configured");
+  });
+
+  test("missing assistant ID returns error", async () => {
+    setPlatformAssistantId("");
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("Assistant ID");
+  });
+
+  test("send without subject omits subject from payload", async () => {
+    mockListAddresses();
+    mockSendSuccess();
+
+    await runAssistantCommand(
+      "email",
+      "send",
+      "user@example.com",
+      "-b",
+      "Body only, no subject",
+    );
+
+    const calls = getMockFetchCalls();
+    const payload = JSON.parse(calls[1].init.body as string);
+    expect(payload.subject).toBeUndefined();
+    expect(payload.text).toBe("Body only, no subject");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("suppressed recipient error is surfaced", async () => {
+    mockListAddresses();
+    mockFetch(
+      "/runtime-proxy/email/send/",
+      { method: "POST" },
+      {
+        body: {
+          detail:
+            "Recipient user@example.com is suppressed due to prior bounce or spam complaint.",
+        },
+        status: 422,
+      },
+    );
+
+    const output = await runAssistantCommand(
+      "email",
+      "--json",
+      "send",
+      "user@example.com",
+      "-s",
+      "Hello",
+      "-b",
+      "Body",
+    );
+
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.error).toContain("suppressed");
+  });
+});