@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/call-routes-http.test.ts

@@ -8,7 +8,6 @@
 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";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));

package/src/__tests__/call-start-guardian-guard.test.ts

@@ -1,6 +1,6 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ToolContext } from '../tools/types.js';
+import type { ToolContext } from "../tools/types.js";
 
 let callsEnabled = true;
 const startCallInputs: Array<Record<string, unknown>> = [];
@@ -9,88 +9,90 @@ let activeVoiceSession: {
   expectedPhoneE164: string | null;
 } | null = null;
 
-mock.module('../config/loader.js', () => ({
+mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    
+
     calls: { enabled: callsEnabled },
   }),
 }));
 
-mock.module('../calls/call-domain.js', () => ({
+mock.module("../calls/call-domain.js", () => ({
   startCall: async (input: Record<string, unknown>) => {
     startCallInputs.push(input);
     return {
       ok: true,
       session: {
-        id: 'call-session-1',
-        toNumber: String(input.phoneNumber ?? ''),
-        fromNumber: '+14155550000',
+        id: "call-session-1",
+        toNumber: String(input.phoneNumber ?? ""),
+        fromNumber: "+14155550000",
       },
-      callSid: 'CA-mock',
-      callerIdentityMode: 'assistant_number',
+      callSid: "CA-mock",
+      callerIdentityMode: "assistant_number",
     };
   },
 }));
 
-mock.module('../runtime/channel-guardian-service.js', () => ({
+mock.module("../runtime/channel-guardian-service.js", () => ({
   findActiveSession: () => activeVoiceSession,
 }));
 
-const { executeCallStart } = await import('../tools/calls/call-start.js');
+const { executeCallStart } = await import("../tools/calls/call-start.js");
 
 function makeContext(): ToolContext {
   return {
-    workingDir: '/tmp',
-    sessionId: 'session-1',
-    conversationId: 'conversation-1',
-    assistantId: 'self',
-    guardianTrustClass: 'guardian',
+    workingDir: "/tmp",
+    sessionId: "session-1",
+    conversationId: "conversation-1",
+    assistantId: "self",
+    guardianTrustClass: "guardian",
   };
 }
 
-describe('call_start guardian verification guard', () => {
+describe("call_start guardian verification guard", () => {
   beforeEach(() => {
     callsEnabled = true;
     startCallInputs.length = 0;
     activeVoiceSession = null;
   });
 
-  test('blocks call_start when voice guardian verification is active for the same number', async () => {
+  test("blocks call_start when voice guardian verification is active for the same number", async () => {
     activeVoiceSession = {
-      destinationAddress: '+14155551234',
-      expectedPhoneE164: '+14155551234',
+      destinationAddress: "+14155551234",
+      expectedPhoneE164: "+14155551234",
     };
 
     const result = await executeCallStart(
       {
-        phone_number: '(415) 555-1234',
-        task: 'Test call while verification is active',
+        phone_number: "(415) 555-1234",
+        task: "Test call while verification is active",
       },
       makeContext(),
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('guardian voice verification call is already active');
+    expect(result.content).toContain(
+      "guardian voice verification call is already active",
+    );
     expect(startCallInputs.length).toBe(0);
   });
 
-  test('allows call_start when active guardian verification targets a different number', async () => {
+  test("allows call_start when active guardian verification targets a different number", async () => {
     activeVoiceSession = {
-      destinationAddress: '+14155550001',
-      expectedPhoneE164: '+14155550001',
+      destinationAddress: "+14155550001",
+      expectedPhoneE164: "+14155550001",
     };
 
     const result = await executeCallStart(
       {
-        phone_number: '+14155551234',
-        task: 'Normal outbound call',
+        phone_number: "+14155551234",
+        task: "Normal outbound call",
       },
       makeContext(),
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain('Call initiated successfully.');
+    expect(result.content).toContain("Call initiated successfully.");
     expect(startCallInputs.length).toBe(1);
   });
 });

package/src/__tests__/call-state-machine.test.ts

@@ -1,37 +1,40 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { isTerminalState,validateTransition } from '../calls/call-state-machine.js';
-import type { CallStatus } from '../calls/types.js';
+import {
+  isTerminalState,
+  validateTransition,
+} from "../calls/call-state-machine.js";
+import type { CallStatus } from "../calls/types.js";
 
-describe('call-state-machine', () => {
+describe("call-state-machine", () => {
   // ── Valid transitions ───────────────────────────────────────────────
 
-  describe('valid transitions', () => {
+  describe("valid transitions", () => {
     const validCases: Array<[CallStatus, CallStatus]> = [
       // From initiated
-      ['initiated', 'ringing'],
-      ['initiated', 'in_progress'],
-      ['initiated', 'completed'],
-      ['initiated', 'failed'],
-      ['initiated', 'cancelled'],
+      ["initiated", "ringing"],
+      ["initiated", "in_progress"],
+      ["initiated", "completed"],
+      ["initiated", "failed"],
+      ["initiated", "cancelled"],
 
       // From ringing
-      ['ringing', 'in_progress'],
-      ['ringing', 'completed'],
-      ['ringing', 'failed'],
-      ['ringing', 'cancelled'],
+      ["ringing", "in_progress"],
+      ["ringing", "completed"],
+      ["ringing", "failed"],
+      ["ringing", "cancelled"],
 
       // From in_progress
-      ['in_progress', 'waiting_on_user'],
-      ['in_progress', 'completed'],
-      ['in_progress', 'failed'],
-      ['in_progress', 'cancelled'],
+      ["in_progress", "waiting_on_user"],
+      ["in_progress", "completed"],
+      ["in_progress", "failed"],
+      ["in_progress", "cancelled"],
 
       // From waiting_on_user
-      ['waiting_on_user', 'in_progress'],
-      ['waiting_on_user', 'completed'],
-      ['waiting_on_user', 'failed'],
-      ['waiting_on_user', 'cancelled'],
+      ["waiting_on_user", "in_progress"],
+      ["waiting_on_user", "completed"],
+      ["waiting_on_user", "failed"],
+      ["waiting_on_user", "cancelled"],
     ];
 
     for (const [from, to] of validCases) {
@@ -45,10 +48,15 @@ describe('call-state-machine', () => {
 
   // ── Same-state transitions (no-op, valid) ──────────────────────────
 
-  describe('same-state transitions', () => {
+  describe("same-state transitions", () => {
     const allStatuses: CallStatus[] = [
-      'initiated', 'ringing', 'in_progress', 'waiting_on_user',
-      'completed', 'failed', 'cancelled',
+      "initiated",
+      "ringing",
+      "in_progress",
+      "waiting_on_user",
+      "completed",
+      "failed",
+      "cancelled",
     ];
 
     for (const status of allStatuses) {
@@ -61,14 +69,14 @@ describe('call-state-machine', () => {
 
   // ── Invalid transitions ─────────────────────────────────────────────
 
-  describe('invalid transitions', () => {
+  describe("invalid transitions", () => {
     const invalidCases: Array<[CallStatus, CallStatus]> = [
       // Cannot skip backwards
-      ['ringing', 'initiated'],
-      ['in_progress', 'initiated'],
-      ['in_progress', 'ringing'],
-      ['waiting_on_user', 'initiated'],
-      ['waiting_on_user', 'ringing'],
+      ["ringing", "initiated"],
+      ["in_progress", "initiated"],
+      ["in_progress", "ringing"],
+      ["waiting_on_user", "initiated"],
+      ["waiting_on_user", "ringing"],
     ];
 
     for (const [from, to] of invalidCases) {
@@ -83,10 +91,13 @@ describe('call-state-machine', () => {
 
   // ── Terminal state immutability ─────────────────────────────────────
 
-  describe('terminal state immutability', () => {
-    const terminalStates: CallStatus[] = ['completed', 'failed', 'cancelled'];
+  describe("terminal state immutability", () => {
+    const terminalStates: CallStatus[] = ["completed", "failed", "cancelled"];
     const nonTerminalTargets: CallStatus[] = [
-      'initiated', 'ringing', 'in_progress', 'waiting_on_user',
+      "initiated",
+      "ringing",
+      "in_progress",
+      "waiting_on_user",
     ];
 
     for (const terminal of terminalStates) {
@@ -94,7 +105,7 @@ describe('call-state-machine', () => {
         test(`${terminal} -> ${target} is rejected (terminal state)`, () => {
           const result = validateTransition(terminal, target);
           expect(result.valid).toBe(false);
-          expect(result.reason).toContain('terminal');
+          expect(result.reason).toContain("terminal");
         });
       }
 
@@ -104,7 +115,7 @@ describe('call-state-machine', () => {
         test(`${terminal} -> ${otherTerminal} is rejected (terminal to terminal)`, () => {
           const result = validateTransition(terminal, otherTerminal);
           expect(result.valid).toBe(false);
-          expect(result.reason).toContain('terminal');
+          expect(result.reason).toContain("terminal");
         });
       }
     }
@@ -112,33 +123,33 @@ describe('call-state-machine', () => {
 
   // ── isTerminalState ─────────────────────────────────────────────────
 
-  describe('isTerminalState', () => {
-    test('completed is terminal', () => {
-      expect(isTerminalState('completed')).toBe(true);
+  describe("isTerminalState", () => {
+    test("completed is terminal", () => {
+      expect(isTerminalState("completed")).toBe(true);
     });
 
-    test('failed is terminal', () => {
-      expect(isTerminalState('failed')).toBe(true);
+    test("failed is terminal", () => {
+      expect(isTerminalState("failed")).toBe(true);
     });
 
-    test('cancelled is terminal', () => {
-      expect(isTerminalState('cancelled')).toBe(true);
+    test("cancelled is terminal", () => {
+      expect(isTerminalState("cancelled")).toBe(true);
     });
 
-    test('initiated is not terminal', () => {
-      expect(isTerminalState('initiated')).toBe(false);
+    test("initiated is not terminal", () => {
+      expect(isTerminalState("initiated")).toBe(false);
     });
 
-    test('ringing is not terminal', () => {
-      expect(isTerminalState('ringing')).toBe(false);
+    test("ringing is not terminal", () => {
+      expect(isTerminalState("ringing")).toBe(false);
     });
 
-    test('in_progress is not terminal', () => {
-      expect(isTerminalState('in_progress')).toBe(false);
+    test("in_progress is not terminal", () => {
+      expect(isTerminalState("in_progress")).toBe(false);
     });
 
-    test('waiting_on_user is not terminal', () => {
-      expect(isTerminalState('waiting_on_user')).toBe(false);
+    test("waiting_on_user is not terminal", () => {
+      expect(isTerminalState("waiting_on_user")).toBe(false);
     });
   });
 });

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

@@ -1,12 +1,13 @@
-import { beforeEach, describe, expect, mock,test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-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: () => () => {},
+    }),
 }));
 
-import type { CallController } from '../calls/call-controller.js';
+import type { CallController } from "../calls/call-controller.js";
 import {
   fireCallCompletionNotifier,
   fireCallQuestionNotifier,
@@ -20,155 +21,168 @@ import {
   unregisterCallController,
   unregisterCallQuestionNotifier,
   unregisterCallTranscriptNotifier,
-} from '../calls/call-state.js';
+} from "../calls/call-state.js";
 
-describe('call-state', () => {
+describe("call-state", () => {
   // Clean up notifiers between tests
   beforeEach(() => {
-    unregisterCallQuestionNotifier('test-conv');
-    unregisterCallTranscriptNotifier('test-conv');
-    unregisterCallCompletionNotifier('test-conv');
-    unregisterCallController('test-session');
+    unregisterCallQuestionNotifier("test-conv");
+    unregisterCallTranscriptNotifier("test-conv");
+    unregisterCallCompletionNotifier("test-conv");
+    unregisterCallController("test-session");
   });
 
   // ── Question notifiers ────────────────────────────────────────────
 
-  test('registerCallQuestionNotifier + fireCallQuestionNotifier: callback receives args', () => {
-    let receivedSessionId = '';
-    let receivedQuestion = '';
+  test("registerCallQuestionNotifier + fireCallQuestionNotifier: callback receives args", () => {
+    let receivedSessionId = "";
+    let receivedQuestion = "";
 
-    registerCallQuestionNotifier('test-conv', (callSessionId, question) => {
+    registerCallQuestionNotifier("test-conv", (callSessionId, question) => {
       receivedSessionId = callSessionId;
       receivedQuestion = question;
     });
 
-    fireCallQuestionNotifier('test-conv', 'session-123', 'What is the date?');
+    fireCallQuestionNotifier("test-conv", "session-123", "What is the date?");
 
-    expect(receivedSessionId).toBe('session-123');
-    expect(receivedQuestion).toBe('What is the date?');
+    expect(receivedSessionId).toBe("session-123");
+    expect(receivedQuestion).toBe("What is the date?");
   });
 
-  test('unregisterCallQuestionNotifier: fire after unregister does nothing', () => {
+  test("unregisterCallQuestionNotifier: fire after unregister does nothing", () => {
     let called = false;
 
-    registerCallQuestionNotifier('test-conv', () => {
+    registerCallQuestionNotifier("test-conv", () => {
       called = true;
     });
 
-    unregisterCallQuestionNotifier('test-conv');
-    fireCallQuestionNotifier('test-conv', 'session-123', 'Some question');
+    unregisterCallQuestionNotifier("test-conv");
+    fireCallQuestionNotifier("test-conv", "session-123", "Some question");
 
     expect(called).toBe(false);
   });
 
-  test('fireCallQuestionNotifier does nothing when no notifier is registered', () => {
+  test("fireCallQuestionNotifier does nothing when no notifier is registered", () => {
     // Should not throw
-    fireCallQuestionNotifier('unregistered-conv', 'session-1', 'question');
+    fireCallQuestionNotifier("unregistered-conv", "session-1", "question");
   });
 
   // ── Transcript notifiers ──────────────────────────────────────────
 
-  test('registerCallTranscriptNotifier + fireCallTranscriptNotifier: callback receives args', () => {
-    let receivedSessionId = '';
-    let receivedSpeaker = '';
-    let receivedText = '';
-
-    registerCallTranscriptNotifier('test-conv', (callSessionId, speaker, text) => {
-      receivedSessionId = callSessionId;
-      receivedSpeaker = speaker;
-      receivedText = text;
-    });
-
-    fireCallTranscriptNotifier('test-conv', 'session-321', 'caller', 'Hello from caller');
-
-    expect(receivedSessionId).toBe('session-321');
-    expect(receivedSpeaker).toBe('caller');
-    expect(receivedText).toBe('Hello from caller');
+  test("registerCallTranscriptNotifier + fireCallTranscriptNotifier: callback receives args", () => {
+    let receivedSessionId = "";
+    let receivedSpeaker = "";
+    let receivedText = "";
+
+    registerCallTranscriptNotifier(
+      "test-conv",
+      (callSessionId, speaker, text) => {
+        receivedSessionId = callSessionId;
+        receivedSpeaker = speaker;
+        receivedText = text;
+      },
+    );
+
+    fireCallTranscriptNotifier(
+      "test-conv",
+      "session-321",
+      "caller",
+      "Hello from caller",
+    );
+
+    expect(receivedSessionId).toBe("session-321");
+    expect(receivedSpeaker).toBe("caller");
+    expect(receivedText).toBe("Hello from caller");
   });
 
-  test('unregisterCallTranscriptNotifier: fire after unregister does nothing', () => {
+  test("unregisterCallTranscriptNotifier: fire after unregister does nothing", () => {
     let called = false;
 
-    registerCallTranscriptNotifier('test-conv', () => {
+    registerCallTranscriptNotifier("test-conv", () => {
       called = true;
     });
 
-    unregisterCallTranscriptNotifier('test-conv');
-    fireCallTranscriptNotifier('test-conv', 'session-321', 'assistant', 'Test');
+    unregisterCallTranscriptNotifier("test-conv");
+    fireCallTranscriptNotifier("test-conv", "session-321", "assistant", "Test");
 
     expect(called).toBe(false);
   });
 
-  test('fireCallTranscriptNotifier does nothing when no notifier is registered', () => {
-    fireCallTranscriptNotifier('unregistered-conv', 'session-1', 'caller', 'text');
+  test("fireCallTranscriptNotifier does nothing when no notifier is registered", () => {
+    fireCallTranscriptNotifier(
+      "unregistered-conv",
+      "session-1",
+      "caller",
+      "text",
+    );
   });
 
   // ── Completion notifiers ──────────────────────────────────────────
 
-  test('registerCallCompletionNotifier + fireCallCompletionNotifier: callback receives callSessionId', () => {
-    let receivedSessionId = '';
+  test("registerCallCompletionNotifier + fireCallCompletionNotifier: callback receives callSessionId", () => {
+    let receivedSessionId = "";
 
-    registerCallCompletionNotifier('test-conv', (callSessionId) => {
+    registerCallCompletionNotifier("test-conv", (callSessionId) => {
       receivedSessionId = callSessionId;
     });
 
-    fireCallCompletionNotifier('test-conv', 'session-456');
+    fireCallCompletionNotifier("test-conv", "session-456");
 
-    expect(receivedSessionId).toBe('session-456');
+    expect(receivedSessionId).toBe("session-456");
   });
 
-  test('unregisterCallCompletionNotifier: fire after unregister does nothing', () => {
+  test("unregisterCallCompletionNotifier: fire after unregister does nothing", () => {
     let called = false;
 
-    registerCallCompletionNotifier('test-conv', () => {
+    registerCallCompletionNotifier("test-conv", () => {
       called = true;
     });
 
-    unregisterCallCompletionNotifier('test-conv');
-    fireCallCompletionNotifier('test-conv', 'session-456');
+    unregisterCallCompletionNotifier("test-conv");
+    fireCallCompletionNotifier("test-conv", "session-456");
 
     expect(called).toBe(false);
   });
 
-  test('fireCallCompletionNotifier does nothing when no notifier is registered', () => {
+  test("fireCallCompletionNotifier does nothing when no notifier is registered", () => {
     // Should not throw
-    fireCallCompletionNotifier('unregistered-conv', 'session-1');
+    fireCallCompletionNotifier("unregistered-conv", "session-1");
   });
 
   // ── Controller registry ─────────────────────────────────────────
 
-  test('registerCallController + getCallController: retrieves controller', () => {
-    const fakeController = { id: 'fake-ctrl' } as unknown as CallController;
+  test("registerCallController + getCallController: retrieves controller", () => {
+    const fakeController = { id: "fake-ctrl" } as unknown as CallController;
 
-    registerCallController('test-session', fakeController);
+    registerCallController("test-session", fakeController);
 
-    const retrieved = getCallController('test-session');
+    const retrieved = getCallController("test-session");
     expect(retrieved).toBe(fakeController);
   });
 
-  test('unregisterCallController: getCallController returns undefined after unregister', () => {
-    const fakeController = { id: 'fake-ctrl-2' } as unknown as CallController;
+  test("unregisterCallController: getCallController returns undefined after unregister", () => {
+    const fakeController = { id: "fake-ctrl-2" } as unknown as CallController;
 
-    registerCallController('test-session', fakeController);
-    unregisterCallController('test-session');
+    registerCallController("test-session", fakeController);
+    unregisterCallController("test-session");
 
-    const retrieved = getCallController('test-session');
+    const retrieved = getCallController("test-session");
     expect(retrieved).toBeUndefined();
   });
 
-  test('getCallController returns undefined for unregistered session', () => {
-    const retrieved = getCallController('nonexistent-session');
+  test("getCallController returns undefined for unregistered session", () => {
+    const retrieved = getCallController("nonexistent-session");
     expect(retrieved).toBeUndefined();
   });
 
-  test('registering a new controller for same session overwrites the previous one', () => {
-    const first = { id: 'first' } as unknown as CallController;
-    const second = { id: 'second' } as unknown as CallController;
+  test("registering a new controller for same session overwrites the previous one", () => {
+    const first = { id: "first" } as unknown as CallController;
+    const second = { id: "second" } as unknown as CallController;
 
-    registerCallController('test-session', first);
-    registerCallController('test-session', second);
+    registerCallController("test-session", first);
+    registerCallController("test-session", second);
 
-    const retrieved = getCallController('test-session');
+    const retrieved = getCallController("test-session");
     expect(retrieved).toBe(second);
   });
 });