vellum 0.2.1 → 0.2.2

package/src/__tests__/relay-server.test.ts

@@ -0,0 +1,633 @@
+/**
+ * Tests for RelayConnection — the WebSocket handler for Twilio
+ * ConversationRelay protocol.
+ *
+ * Tests:
+ * - Setup message handling (callSid association, event recording, orchestrator creation)
+ * - Prompt message handling (final vs partial, routing to orchestrator)
+ * - Interrupt handling (abort propagation)
+ * - Error handling (event recording)
+ * - DTMF handling (event recording)
+ * - sendTextToken / endSession (outbound WebSocket messages)
+ * - Conversation history tracking
+ * - destroy cleanup
+ * - Malformed message resilience
+ */
+import { describe, test, expect, beforeEach, afterAll, mock, type Mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { EventEmitter } from 'node:events';
+
+const testDir = mkdtempSync(join(tmpdir(), 'relay-server-test-'));
+
+// ── Platform + logger mocks (must come before any source imports) ────
+
+mock.module('../util/platform.js', () => ({
+  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'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Config mock ─────────────────────────────────────────────────────
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({
+    apiKeys: { anthropic: 'test-key' },
+    calls: {
+      enabled: true,
+      provider: 'twilio',
+      maxDurationSeconds: 3600,
+      userConsultTimeoutSeconds: 120,
+      disclosure: { enabled: false, text: '' },
+      safety: { denyCategories: [] },
+    },
+  }),
+}));
+
+// ── Anthropic SDK mock ──────────────────────────────────────────────
+
+function createMockStream(tokens: string[]) {
+  const emitter = new EventEmitter();
+  const fullText = tokens.join('');
+
+  const stream = {
+    on: (event: string, handler: (...args: unknown[]) => void) => {
+      emitter.on(event, handler);
+      return stream;
+    },
+    finalMessage: () => {
+      for (const token of tokens) {
+        emitter.emit('text', token);
+      }
+      return Promise.resolve({
+        content: [{ type: 'text', text: fullText }],
+      });
+    },
+  };
+
+  return stream;
+}
+
+let mockStreamFn: Mock<(...args: unknown[]) => unknown>;
+
+mock.module('@anthropic-ai/sdk', () => {
+  mockStreamFn = mock((..._args: unknown[]) => createMockStream(['Hello']));
+  return {
+    default: class MockAnthropic {
+      messages = {
+        stream: (...args: unknown[]) => mockStreamFn(...args),
+      };
+    },
+  };
+});
+
+// ── Import source modules after all mocks ────────────────────────────
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { conversations } from '../memory/schema.js';
+import {
+  createCallSession,
+  getCallSession,
+  getCallEvents,
+} from '../calls/call-store.js';
+import { RelayConnection, activeRelayConnections } from '../calls/relay-server.js';
+import type { RelayWebSocketData } from '../calls/relay-server.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+// ── Mock WebSocket factory ──────────────────────────────────────────
+
+interface MockWs {
+  sentMessages: string[];
+  readyState: number;
+}
+
+function createMockWs(callSessionId: string): { ws: MockWs; relay: RelayConnection } {
+  const sentMessages: string[] = [];
+  const ws = {
+    sentMessages,
+    readyState: 1, // WebSocket.OPEN
+    send(data: string) {
+      sentMessages.push(data);
+    },
+    data: { callSessionId } as RelayWebSocketData,
+  };
+
+  const relay = new RelayConnection(ws as unknown as import('bun').ServerWebSocket<RelayWebSocketData>, callSessionId);
+  return { ws, relay };
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+let ensuredConvIds = new Set<string>();
+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();
+  ensuredConvIds.add(id);
+}
+
+function resetTables() {
+  const db = getDb();
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM conversations');
+  ensuredConvIds = new Set();
+}
+
+describe('relay-server', () => {
+  beforeEach(() => {
+    resetTables();
+    activeRelayConnections.clear();
+    mockStreamFn.mockImplementation(() => createMockStream(['Hello']));
+  });
+
+  // ── Setup message handling ──────────────────────────────────────
+
+  test('handleMessage: setup message associates callSid and records event', async () => {
+    ensureConversation('conv-relay-1');
+    const session = createCallSession({
+      conversationId: 'conv-relay-1',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_relay_setup_123',
+      from: '+15551111111',
+      to: '+15552222222',
+    }));
+
+    // Verify callSid was stored on the session
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.providerCallSid).toBe('CA_relay_setup_123');
+
+    // Verify event was recorded
+    const events = getCallEvents(session.id);
+    const connectedEvents = events.filter(e => e.eventType === 'call_connected');
+    expect(connectedEvents.length).toBe(1);
+
+    // Verify orchestrator was created
+    expect(relay.getOrchestrator()).not.toBeNull();
+
+    relay.destroy();
+  });
+
+  test('handleMessage: setup message with custom parameters', async () => {
+    ensureConversation('conv-relay-custom');
+    const session = createCallSession({
+      conversationId: 'conv-relay-custom',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+      task: 'Book appointment',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_relay_custom_123',
+      from: '+15551111111',
+      to: '+15552222222',
+      customParameters: { taskId: 'task-1', priority: 'high' },
+    }));
+
+    // Verify event recorded with custom parameters
+    const events = getCallEvents(session.id);
+    expect(events.length).toBe(1);
+    const payload = JSON.parse(events[0].payloadJson);
+    expect(payload.customParameters).toEqual({ taskId: 'task-1', priority: 'high' });
+
+    relay.destroy();
+  });
+
+  // ── Prompt message handling ─────────────────────────────────────
+
+  test('handleMessage: final prompt routes to orchestrator and records event', async () => {
+    ensureConversation('conv-relay-prompt');
+    const session = createCallSession({
+      conversationId: 'conv-relay-prompt',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    // First, setup to create orchestrator
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_prompt_123',
+      from: '+15551111111',
+      to: '+15552222222',
+    }));
+
+    // Now send a final prompt
+    await relay.handleMessage(JSON.stringify({
+      type: 'prompt',
+      voicePrompt: 'Hello, I need to make a reservation',
+      lang: 'en-US',
+      last: true,
+    }));
+
+    // Verify event was recorded
+    const events = getCallEvents(session.id);
+    const spokeEvents = events.filter(e => e.eventType === 'caller_spoke');
+    expect(spokeEvents.length).toBe(1);
+    const payload = JSON.parse(spokeEvents[0].payloadJson);
+    expect(payload.transcript).toBe('Hello, I need to make a reservation');
+
+    // Verify conversation history was updated
+    const history = relay.getConversationHistory();
+    expect(history.length).toBe(1);
+    expect(history[0].role).toBe('caller');
+    expect(history[0].text).toBe('Hello, I need to make a reservation');
+
+    // Verify tokens were sent through the WebSocket
+    expect(ws.sentMessages.length).toBeGreaterThan(0);
+
+    relay.destroy();
+  });
+
+  test('handleMessage: partial prompt (last=false) does not route to orchestrator', async () => {
+    ensureConversation('conv-relay-partial');
+    const session = createCallSession({
+      conversationId: 'conv-relay-partial',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    // Setup
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_partial_123',
+      from: '+15551111111',
+      to: '+15552222222',
+    }));
+
+    const messagesBeforePrompt = ws.sentMessages.length;
+
+    // Send a partial prompt (last=false)
+    await relay.handleMessage(JSON.stringify({
+      type: 'prompt',
+      voicePrompt: 'Hello, I need...',
+      lang: 'en-US',
+      last: false,
+    }));
+
+    // Should not have generated any new text tokens (no LLM call for partials)
+    // Only the setup-related messages should exist
+    expect(ws.sentMessages.length).toBe(messagesBeforePrompt);
+
+    // Conversation history should not have been updated for partials
+    const history = relay.getConversationHistory();
+    expect(history.length).toBe(0);
+
+    relay.destroy();
+  });
+
+  test('handleMessage: prompt without orchestrator sends fallback', async () => {
+    ensureConversation('conv-relay-no-orch');
+    const session = createCallSession({
+      conversationId: 'conv-relay-no-orch',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+    // Note: no setup message, so no orchestrator
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'prompt',
+      voicePrompt: 'Hello',
+      lang: 'en-US',
+      last: true,
+    }));
+
+    // Should have sent a fallback message
+    const textMessages = ws.sentMessages
+      .map(m => JSON.parse(m))
+      .filter((m: { type: string }) => m.type === 'text');
+    expect(textMessages.length).toBe(1);
+    expect(textMessages[0].token).toContain('still setting up');
+    expect(textMessages[0].last).toBe(true);
+
+    relay.destroy();
+  });
+
+  // ── Interrupt handling ──────────────────────────────────────────
+
+  test('handleMessage: interrupt message is handled without error', async () => {
+    ensureConversation('conv-relay-int');
+    const session = createCallSession({
+      conversationId: 'conv-relay-int',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Setup
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_int_123',
+      from: '+15551111111',
+      to: '+15552222222',
+    }));
+
+    // Interrupt should not throw
+    await relay.handleMessage(JSON.stringify({
+      type: 'interrupt',
+      utteranceUntilInterrupt: 'Hello, I was saying...',
+    }));
+
+    relay.destroy();
+  });
+
+  // ── DTMF handling ───────────────────────────────────────────────
+
+  test('handleMessage: dtmf digit records event', async () => {
+    ensureConversation('conv-relay-dtmf');
+    const session = createCallSession({
+      conversationId: 'conv-relay-dtmf',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'dtmf',
+      digit: '5',
+    }));
+
+    const events = getCallEvents(session.id);
+    const dtmfEvents = events.filter(e => e.eventType === 'caller_spoke');
+    expect(dtmfEvents.length).toBe(1);
+    const payload = JSON.parse(dtmfEvents[0].payloadJson);
+    expect(payload.dtmfDigit).toBe('5');
+
+    relay.destroy();
+  });
+
+  // ── Error handling ──────────────────────────────────────────────
+
+  test('handleMessage: error message records call_failed event', async () => {
+    ensureConversation('conv-relay-err');
+    const session = createCallSession({
+      conversationId: 'conv-relay-err',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(JSON.stringify({
+      type: 'error',
+      description: 'Audio stream disconnected',
+    }));
+
+    const events = getCallEvents(session.id);
+    const failEvents = events.filter(e => e.eventType === 'call_failed');
+    expect(failEvents.length).toBe(1);
+    const payload = JSON.parse(failEvents[0].payloadJson);
+    expect(payload.error).toBe('Audio stream disconnected');
+
+    relay.destroy();
+  });
+
+  // ── Malformed message resilience ────────────────────────────────
+
+  test('handleMessage: malformed JSON does not throw', async () => {
+    ensureConversation('conv-relay-malformed');
+    const session = createCallSession({
+      conversationId: 'conv-relay-malformed',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Should not throw
+    await relay.handleMessage('not-valid-json{{{');
+
+    relay.destroy();
+  });
+
+  test('handleMessage: unknown message type does not throw', async () => {
+    ensureConversation('conv-relay-unknown');
+    const session = createCallSession({
+      conversationId: 'conv-relay-unknown',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Should not throw
+    await relay.handleMessage(JSON.stringify({
+      type: 'some_future_type',
+      data: 'whatever',
+    }));
+
+    relay.destroy();
+  });
+
+  // ── sendTextToken / endSession ──────────────────────────────────
+
+  test('sendTextToken: sends correctly formatted text message', () => {
+    ensureConversation('conv-relay-send');
+    const session = createCallSession({
+      conversationId: 'conv-relay-send',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    relay.sendTextToken('Hello there', false);
+    relay.sendTextToken('', true);
+
+    expect(ws.sentMessages.length).toBe(2);
+
+    const msg1 = JSON.parse(ws.sentMessages[0]);
+    expect(msg1.type).toBe('text');
+    expect(msg1.token).toBe('Hello there');
+    expect(msg1.last).toBe(false);
+
+    const msg2 = JSON.parse(ws.sentMessages[1]);
+    expect(msg2.type).toBe('text');
+    expect(msg2.token).toBe('');
+    expect(msg2.last).toBe(true);
+
+    relay.destroy();
+  });
+
+  test('endSession: sends end message without reason', () => {
+    ensureConversation('conv-relay-end');
+    const session = createCallSession({
+      conversationId: 'conv-relay-end',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    relay.endSession();
+
+    expect(ws.sentMessages.length).toBe(1);
+    const msg = JSON.parse(ws.sentMessages[0]);
+    expect(msg.type).toBe('end');
+    expect(msg.handoffData).toBeUndefined();
+
+    relay.destroy();
+  });
+
+  test('endSession: sends end message with reason as handoffData', () => {
+    ensureConversation('conv-relay-end-reason');
+    const session = createCallSession({
+      conversationId: 'conv-relay-end-reason',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    relay.endSession('Call completed');
+
+    expect(ws.sentMessages.length).toBe(1);
+    const msg = JSON.parse(ws.sentMessages[0]);
+    expect(msg.type).toBe('end');
+    const handoff = JSON.parse(msg.handoffData);
+    expect(handoff.reason).toBe('Call completed');
+
+    relay.destroy();
+  });
+
+  // ── Conversation history ────────────────────────────────────────
+
+  test('getConversationHistory: returns role and text without timestamps', () => {
+    ensureConversation('conv-relay-hist');
+    const session = createCallSession({
+      conversationId: 'conv-relay-hist',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Empty initially
+    expect(relay.getConversationHistory()).toEqual([]);
+
+    relay.destroy();
+  });
+
+  // ── Accessors ───────────────────────────────────────────────────
+
+  test('getCallSessionId: returns the call session ID', () => {
+    ensureConversation('conv-relay-id');
+    const session = createCallSession({
+      conversationId: 'conv-relay-id',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+    expect(relay.getCallSessionId()).toBe(session.id);
+
+    relay.destroy();
+  });
+
+  // ── destroy ─────────────────────────────────────────────────────
+
+  test('destroy: cleans up orchestrator', async () => {
+    ensureConversation('conv-relay-destroy');
+    const session = createCallSession({
+      conversationId: 'conv-relay-destroy',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    // Setup creates orchestrator
+    await relay.handleMessage(JSON.stringify({
+      type: 'setup',
+      callSid: 'CA_destroy_123',
+      from: '+15551111111',
+      to: '+15552222222',
+    }));
+
+    expect(relay.getOrchestrator()).not.toBeNull();
+
+    relay.destroy();
+
+    expect(relay.getOrchestrator()).toBeNull();
+  });
+
+  test('destroy: can be called multiple times without error', () => {
+    ensureConversation('conv-relay-destroy2');
+    const session = createCallSession({
+      conversationId: 'conv-relay-destroy2',
+      provider: 'twilio',
+      fromNumber: '+15551111111',
+      toNumber: '+15552222222',
+    });
+
+    const { relay } = createMockWs(session.id);
+
+    relay.destroy();
+    expect(() => relay.destroy()).not.toThrow();
+  });
+});

package/src/__tests__/reminder-store.test.ts

@@ -1,6 +1,5 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { initializeDb } from '../memory/db.js';
-import { getDb } from '../memory/db.js';
+import { afterAll, describe, test, expect, beforeEach } from 'bun:test';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { reminders } from '../memory/schema.js';
 import {
   insertReminder,
@@ -19,6 +18,10 @@ function clearReminders() {
   getDb().delete(reminders).run();
 }
 
+afterAll(() => {
+  resetDb();
+});
+
 describe('reminder-store', () => {
   beforeEach(() => {
     clearReminders();