@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/call-domain.test.ts

@@ -6,68 +6,72 @@
  * - Strict implicit-default policy for caller identity.
  * - Pointer messages are written on successful call start and on failure.
  */
-import { mkdtempSync, realpathSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { afterAll, beforeEach, describe, expect, mock,test } from 'bun:test';
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), "call-domain-test-")));
 
-const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'call-domain-test-')));
-
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
 // Track whether the Twilio provider's initiateCall should succeed or throw
-let twilioInitiateCallBehavior: 'success' | 'error' = 'success';
+let twilioInitiateCallBehavior: "success" | "error" = "success";
 
-mock.module('../calls/twilio-config.js', () => ({
+mock.module("../calls/twilio-config.js", () => ({
   getTwilioConfig: (assistantId?: string) => ({
-    accountSid: 'AC_test',
-    authToken: 'test_token',
-    phoneNumber: assistantId === 'ast-alpha' ? '+15550003333' : '+15550001111',
-    webhookBaseUrl: 'https://test.example.com',
-    wssBaseUrl: 'wss://test.example.com',
+    accountSid: "AC_test",
+    authToken: "test_token",
+    phoneNumber: assistantId === "ast-alpha" ? "+15550003333" : "+15550001111",
+    webhookBaseUrl: "https://test.example.com",
+    wssBaseUrl: "wss://test.example.com",
   }),
 }));
 
-mock.module('../calls/twilio-provider.js', () => ({
+mock.module("../calls/twilio-provider.js", () => ({
   TwilioConversationRelayProvider: class {
     async checkCallerIdEligibility(number: string) {
-      if (number === '+15550002222') return { eligible: true };
-      return { eligible: false, reason: `${number} is not eligible as a caller ID` };
+      if (number === "+15550002222") return { eligible: true };
+      return {
+        eligible: false,
+        reason: `${number} is not eligible as a caller ID`,
+      };
     }
     async initiateCall() {
-      if (twilioInitiateCallBehavior === 'error') throw new Error('Twilio unavailable');
-      return { callSid: 'CA_test_123' };
+      if (twilioInitiateCallBehavior === "error")
+        throw new Error("Twilio unavailable");
+      return { callSid: "CA_test_123" };
     }
   },
 }));
 
-mock.module('../security/secure-keys.js', () => ({
+mock.module("../security/secure-keys.js", () => ({
   getSecureKey: () => null,
 }));
 
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   loadConfig: () => ({
     calls: {
       enabled: true,
-      provider: 'twilio',
+      provider: "twilio",
       callerIdentity: { allowPerCallOverride: true },
     },
     memory: { enabled: false },
@@ -75,31 +79,33 @@ mock.module('../config/loader.js', () => ({
   getConfig: () => ({
     calls: {
       enabled: true,
-      provider: 'twilio',
+      provider: "twilio",
       callerIdentity: { allowPerCallOverride: true },
     },
     memory: { enabled: false },
   }),
 }));
 
-mock.module('../inbound/platform-callback-registration.js', () => ({
+mock.module("../inbound/platform-callback-registration.js", () => ({
   resolveCallbackUrl: async (fn: () => string) => fn(),
 }));
 
-mock.module('../inbound/public-ingress-urls.js', () => ({
-  getTwilioVoiceWebhookUrl: () => 'https://test.example.com/webhooks/twilio/voice/test',
-  getTwilioStatusCallbackUrl: () => 'https://test.example.com/webhooks/twilio/status',
+mock.module("../inbound/public-ingress-urls.js", () => ({
+  getTwilioVoiceWebhookUrl: () =>
+    "https://test.example.com/webhooks/twilio/voice/test",
+  getTwilioStatusCallbackUrl: () =>
+    "https://test.example.com/webhooks/twilio/status",
 }));
 
-mock.module('../memory/conversation-title-service.js', () => ({
+mock.module("../memory/conversation-title-service.js", () => ({
   queueGenerateConversationTitle: () => {},
 }));
 
-import { resolveCallerIdentity, startCall } from '../calls/call-domain.js';
-import type { AssistantConfig } from '../config/types.js';
-import { getMessages } from '../memory/conversation-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
-import { conversations } from '../memory/schema.js';
+import { resolveCallerIdentity, startCall } from "../calls/call-domain.js";
+import type { AssistantConfig } from "../config/types.js";
+import { getMessages } from "../memory/conversation-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { conversations } from "../memory/schema.js";
 
 initializeDb();
 
@@ -108,51 +114,66 @@ function ensureConversation(id: string): void {
   if (ensuredConvIds.has(id)) return;
   const db = getDb();
   const now = Date.now();
-  db.insert(conversations).values({
-    id,
-    title: `Test conversation ${id}`,
-    createdAt: now,
-    updatedAt: now,
-  }).run();
+  db.insert(conversations)
+    .values({
+      id,
+      title: `Test conversation ${id}`,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
   ensuredConvIds.add(id);
 }
 
 function resetTables(): void {
   const db = getDb();
-  db.run('DELETE FROM external_conversation_bindings');
-  db.run('DELETE FROM call_sessions');
-  db.run('DELETE FROM messages');
-  db.run('DELETE FROM conversations');
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM call_sessions");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
   ensuredConvIds = new Set();
 }
 
 function getLatestAssistantText(conversationId: string): string | null {
-  const msgs = getMessages(conversationId).filter((m) => m.role === 'assistant');
+  const msgs = getMessages(conversationId).filter(
+    (m) => m.role === "assistant",
+  );
   if (msgs.length === 0) return null;
   const latest = msgs[msgs.length - 1];
   try {
     const parsed = JSON.parse(latest.content) as unknown;
     if (Array.isArray(parsed)) {
       return parsed
-        .filter((b): b is { type: string; text?: string } => typeof b === 'object' && b != null)
-        .filter((b) => b.type === 'text')
-        .map((b) => b.text ?? '')
-        .join('');
+        .filter(
+          (b): b is { type: string; text?: string } =>
+            typeof b === "object" && b != null,
+        )
+        .filter((b) => b.type === "text")
+        .map((b) => b.text ?? "")
+        .join("");
     }
-    if (typeof parsed === 'string') return parsed;
-  } catch { /* fall through */ }
+    if (typeof parsed === "string") return parsed;
+  } catch {
+    /* fall through */
+  }
   return latest.content;
 }
 
 afterAll(() => {
   resetDb();
-  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
 });
 
-function makeConfig(overrides: {
-  allowPerCallOverride?: boolean;
-  userNumber?: string;
-} = {}): AssistantConfig {
+function makeConfig(
+  overrides: {
+    allowPerCallOverride?: boolean;
+    userNumber?: string;
+  } = {},
+): AssistantConfig {
   return {
     calls: {
       callerIdentity: {
@@ -163,119 +184,126 @@ function makeConfig(overrides: {
   } as unknown as AssistantConfig;
 }
 
-describe('resolveCallerIdentity — strict implicit-default policy', () => {
-  test('implicit call defaults to assistant_number', async () => {
+describe("resolveCallerIdentity — strict implicit-default policy", () => {
+  test("implicit call defaults to assistant_number", async () => {
     const result = await resolveCallerIdentity(makeConfig());
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.mode).toBe('assistant_number');
-      expect(result.fromNumber).toBe('+15550001111');
-      expect(result.source).toBe('implicit_default');
+      expect(result.mode).toBe("assistant_number");
+      expect(result.fromNumber).toBe("+15550001111");
+      expect(result.source).toBe("implicit_default");
     }
   });
 
-  test('implicit call uses assistant_number even when userNumber is configured', async () => {
+  test("implicit call uses assistant_number even when userNumber is configured", async () => {
     const result = await resolveCallerIdentity(
-      makeConfig({ userNumber: '+15550002222' }),
+      makeConfig({ userNumber: "+15550002222" }),
     );
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.mode).toBe('assistant_number');
-      expect(result.fromNumber).toBe('+15550001111');
-      expect(result.source).toBe('implicit_default');
+      expect(result.mode).toBe("assistant_number");
+      expect(result.fromNumber).toBe("+15550001111");
+      expect(result.source).toBe("implicit_default");
     }
   });
 
-  test('assistant_number resolves from assistant-scoped Twilio number when assistantId is provided', async () => {
-    const result = await resolveCallerIdentity(makeConfig(), undefined, 'ast-alpha');
+  test("assistant_number resolves from assistant-scoped Twilio number when assistantId is provided", async () => {
+    const result = await resolveCallerIdentity(
+      makeConfig(),
+      undefined,
+      "ast-alpha",
+    );
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.mode).toBe('assistant_number');
-      expect(result.fromNumber).toBe('+15550003333');
-      expect(result.source).toBe('implicit_default');
+      expect(result.mode).toBe("assistant_number");
+      expect(result.fromNumber).toBe("+15550003333");
+      expect(result.source).toBe("implicit_default");
     }
   });
 
-  test('explicit user_number succeeds when eligible', async () => {
+  test("explicit user_number succeeds when eligible", async () => {
     const result = await resolveCallerIdentity(
-      makeConfig({ userNumber: '+15550002222' }),
-      'user_number',
+      makeConfig({ userNumber: "+15550002222" }),
+      "user_number",
     );
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.mode).toBe('user_number');
-      expect(result.fromNumber).toBe('+15550002222');
-      expect(result.source).toBe('user_config');
+      expect(result.mode).toBe("user_number");
+      expect(result.fromNumber).toBe("+15550002222");
+      expect(result.source).toBe("user_config");
     }
   });
 
-  test('explicit user_number fails when no user phone configured', async () => {
-    const result = await resolveCallerIdentity(makeConfig(), 'user_number');
+  test("explicit user_number fails when no user phone configured", async () => {
+    const result = await resolveCallerIdentity(makeConfig(), "user_number");
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error).toContain('user_number');
-      expect(result.error).toContain('user phone number');
+      expect(result.error).toContain("user_number");
+      expect(result.error).toContain("user phone number");
     }
   });
 
-  test('explicit user_number fails when number is ineligible', async () => {
+  test("explicit user_number fails when number is ineligible", async () => {
     const result = await resolveCallerIdentity(
-      makeConfig({ userNumber: '+15559999999' }),
-      'user_number',
+      makeConfig({ userNumber: "+15559999999" }),
+      "user_number",
     );
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error).toContain('not eligible');
+      expect(result.error).toContain("not eligible");
     }
   });
 
-  test('explicit override rejected when allowPerCallOverride=false', async () => {
+  test("explicit override rejected when allowPerCallOverride=false", async () => {
     const result = await resolveCallerIdentity(
-      makeConfig({ allowPerCallOverride: false, userNumber: '+15550002222' }),
-      'user_number',
+      makeConfig({ allowPerCallOverride: false, userNumber: "+15550002222" }),
+      "user_number",
     );
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error).toContain('override is disabled');
+      expect(result.error).toContain("override is disabled");
     }
   });
 
-  test('explicit assistant_number override succeeds when allowed', async () => {
-    const result = await resolveCallerIdentity(makeConfig(), 'assistant_number');
+  test("explicit assistant_number override succeeds when allowed", async () => {
+    const result = await resolveCallerIdentity(
+      makeConfig(),
+      "assistant_number",
+    );
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.mode).toBe('assistant_number');
-      expect(result.source).toBe('per_call_override');
+      expect(result.mode).toBe("assistant_number");
+      expect(result.source).toBe("per_call_override");
     }
   });
 
-  test('invalid mode returns error', async () => {
+  test("invalid mode returns error", async () => {
     const result = await resolveCallerIdentity(
       makeConfig(),
-      'custom_number' as 'assistant_number',
+      "custom_number" as "assistant_number",
     );
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error).toContain('Invalid callerIdentityMode');
+      expect(result.error).toContain("Invalid callerIdentityMode");
     }
   });
 });
 
 // ── Pointer message regression tests ──────────────────────────────
 
-describe('startCall — pointer message regression', () => {
+describe("startCall — pointer message regression", () => {
   beforeEach(() => {
     resetTables();
-    twilioInitiateCallBehavior = 'success';
+    twilioInitiateCallBehavior = "success";
   });
 
-  test('successful call writes a started pointer to the initiating conversation', async () => {
-    const convId = 'conv-domain-ptr-start';
+  test("successful call writes a started pointer to the initiating conversation", async () => {
+    const convId = "conv-domain-ptr-start";
     ensureConversation(convId);
 
     const result = await startCall({
-      phoneNumber: '+15559876543',
-      task: 'Test call',
+      phoneNumber: "+15559876543",
+      task: "Test call",
       conversationId: convId,
     });
 
@@ -285,18 +313,18 @@ describe('startCall — pointer message regression', () => {
 
     const text = getLatestAssistantText(convId);
     expect(text).not.toBeNull();
-    expect(text!).toContain('+15559876543');
-    expect(text!).toContain('started');
+    expect(text!).toContain("+15559876543");
+    expect(text!).toContain("started");
   });
 
-  test('failed call writes a failed pointer to the initiating conversation', async () => {
-    const convId = 'conv-domain-ptr-fail';
+  test("failed call writes a failed pointer to the initiating conversation", async () => {
+    const convId = "conv-domain-ptr-fail";
     ensureConversation(convId);
-    twilioInitiateCallBehavior = 'error';
+    twilioInitiateCallBehavior = "error";
 
     const result = await startCall({
-      phoneNumber: '+15559876543',
-      task: 'Test call',
+      phoneNumber: "+15559876543",
+      task: "Test call",
       conversationId: convId,
     });
 
@@ -306,7 +334,7 @@ describe('startCall — pointer message regression', () => {
 
     const text = getLatestAssistantText(convId);
     expect(text).not.toBeNull();
-    expect(text!).toContain('+15559876543');
-    expect(text!).toContain('failed');
+    expect(text!).toContain("+15559876543");
+    expect(text!).toContain("failed");
   });
 });