@vellumai/assistant 0.4.5 → 0.4.7

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

@@ -1,17 +1,16 @@
 /**
- * Unit tests for caller identity resolution in call-domain.ts.
+ * Unit tests for caller identity resolution and pointer message regression
+ * in call-domain.ts.
  *
- * Validates the strict implicit-default policy:
- * - Implicit calls (no explicit mode) always use assistant_number.
- * - Explicit user_number calls succeed when eligible.
- * - Explicit user_number calls fail clearly when missing/ineligible.
- * - Explicit override rejected when allowPerCallOverride=false.
+ * Validates:
+ * - Strict implicit-default policy for caller identity.
+ * - Pointer messages are written on successful call start and on failure.
  */
-import { mkdtempSync, realpathSync } from 'node:fs';
+import { mkdtempSync, realpathSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { 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-')));
 
@@ -34,6 +33,9 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
+// Track whether the Twilio provider's initiateCall should succeed or throw
+let twilioInitiateCallBehavior: 'success' | 'error' = 'success';
+
 mock.module('../calls/twilio-config.js', () => ({
   getTwilioConfig: (assistantId?: string) => ({
     accountSid: 'AC_test',
@@ -47,10 +49,13 @@ mock.module('../calls/twilio-config.js', () => ({
 mock.module('../calls/twilio-provider.js', () => ({
   TwilioConversationRelayProvider: class {
     async checkCallerIdEligibility(number: string) {
-      // Simulate: +15550002222 is eligible, others are not
       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' };
+    }
   },
 }));
 
@@ -58,8 +63,91 @@ mock.module('../security/secure-keys.js', () => ({
   getSecureKey: () => null,
 }));
 
-import { resolveCallerIdentity } from '../calls/call-domain.js';
+mock.module('../config/loader.js', () => ({
+  loadConfig: () => ({
+    calls: {
+      enabled: true,
+      provider: 'twilio',
+      callerIdentity: { allowPerCallOverride: true },
+    },
+    memory: { enabled: false },
+  }),
+  getConfig: () => ({
+    calls: {
+      enabled: true,
+      provider: 'twilio',
+      callerIdentity: { allowPerCallOverride: true },
+    },
+    memory: { enabled: false },
+  }),
+}));
+
+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('../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';
+
+initializeDb();
+
+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(): 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');
+  ensuredConvIds = new Set();
+}
+
+function getLatestAssistantText(conversationId: string): string | null {
+  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('');
+    }
+    if (typeof parsed === 'string') return parsed;
+  } catch { /* fall through */ }
+  return latest.content;
+}
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
 
 function makeConfig(overrides: {
   allowPerCallOverride?: boolean;
@@ -172,3 +260,53 @@ describe('resolveCallerIdentity — strict implicit-default policy', () => {
     }
   });
 });
+
+// ── Pointer message regression tests ──────────────────────────────
+
+describe('startCall — pointer message regression', () => {
+  beforeEach(() => {
+    resetTables();
+    twilioInitiateCallBehavior = 'success';
+  });
+
+  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',
+      conversationId: convId,
+    });
+
+    expect(result.ok).toBe(true);
+    // Allow async pointer write to flush
+    await new Promise((r) => setTimeout(r, 50));
+
+    const text = getLatestAssistantText(convId);
+    expect(text).not.toBeNull();
+    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';
+    ensureConversation(convId);
+    twilioInitiateCallBehavior = 'error';
+
+    const result = await startCall({
+      phoneNumber: '+15559876543',
+      task: 'Test call',
+      conversationId: convId,
+    });
+
+    expect(result.ok).toBe(false);
+    // Allow async pointer write to flush
+    await new Promise((r) => setTimeout(r, 50));
+
+    const text = getLatestAssistantText(convId);
+    expect(text).not.toBeNull();
+    expect(text!).toContain('+15559876543');
+    expect(text!).toContain('failed');
+  });
+});

package/src/__tests__/call-pointer-message-composer.test.ts

@@ -9,11 +9,9 @@ mock.module('../util/logger.js', () => ({
 }));
 
 import {
-  buildPointerGenerationPrompt,
+  buildPointerInstruction,
   type CallPointerMessageContext,
-  composeCallPointerMessageGenerative,
   getPointerFallbackMessage,
-  includesRequiredFacts,
 } from '../calls/call-pointer-message-composer.js';
 
 // ---------------------------------------------------------------------------
@@ -105,67 +103,59 @@ describe('getPointerFallbackMessage', () => {
 });
 
 // ---------------------------------------------------------------------------
-// Required facts validation
+// Daemon instruction builder
 // ---------------------------------------------------------------------------
 
-describe('includesRequiredFacts', () => {
-  test('returns true when no required facts', () => {
-    expect(includesRequiredFacts('any text', undefined)).toBe(true);
-    expect(includesRequiredFacts('any text', [])).toBe(true);
+describe('buildPointerInstruction', () => {
+  test('includes event tag, scenario, and phone number', () => {
+    const ctx: CallPointerMessageContext = { scenario: 'started', phoneNumber: '+15551234567' };
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('[CALL_STATUS_EVENT]');
+    expect(instruction).toContain('Event: started');
+    expect(instruction).toContain('Phone number: +15551234567');
   });
 
-  test('returns true when all facts present', () => {
-    expect(includesRequiredFacts('Call to +15551234567 completed (2m).', ['+15551234567', '2m'])).toBe(true);
+  test('includes duration when provided', () => {
+    const ctx: CallPointerMessageContext = { scenario: 'completed', phoneNumber: '+15559876543', duration: '3m' };
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('Duration: 3m');
   });
 
-  test('returns false when a fact is missing', () => {
-    expect(includesRequiredFacts('Call completed.', ['+15551234567'])).toBe(false);
+  test('includes reason when provided', () => {
+    const ctx: CallPointerMessageContext = { scenario: 'failed', phoneNumber: '+15559876543', reason: 'no answer' };
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('Reason: no answer');
   });
-});
 
-// ---------------------------------------------------------------------------
-// Prompt builder
-// ---------------------------------------------------------------------------
-
-describe('buildPointerGenerationPrompt', () => {
-  test('includes context JSON and fallback message', () => {
-    const ctx: CallPointerMessageContext = { scenario: 'started', phoneNumber: '+15551234567' };
-    const prompt = buildPointerGenerationPrompt(ctx, 'Fallback text', undefined);
-    expect(prompt).toContain(JSON.stringify(ctx));
-    expect(prompt).toContain('Fallback text');
+  test('includes verification code when provided', () => {
+    const ctx: CallPointerMessageContext = { scenario: 'started', phoneNumber: '+15551234567', verificationCode: '42' };
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('Verification code: 42');
   });
 
-  test('includes required facts clause when provided', () => {
-    const ctx: CallPointerMessageContext = { scenario: 'completed', phoneNumber: '+15559876543', duration: '3m' };
-    const prompt = buildPointerGenerationPrompt(ctx, 'Fallback', ['+15559876543', '3m']);
-    expect(prompt).toContain('Required facts to include');
-    expect(prompt).toContain('+15559876543');
-    expect(prompt).toContain('3m');
+  test('includes channel when provided', () => {
+    const ctx: CallPointerMessageContext = {
+      scenario: 'guardian_verification_succeeded',
+      phoneNumber: '+15559876543',
+      channel: 'sms',
+    };
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('Channel: sms');
   });
-});
-
-// ---------------------------------------------------------------------------
-// Generative composition (test env falls back to deterministic)
-// ---------------------------------------------------------------------------
 
-describe('composeCallPointerMessageGenerative', () => {
-  test('returns fallback in test environment regardless of generator', async () => {
-    const generator = async () => 'LLM-generated copy';
+  test('omits optional fields when not provided', () => {
     const ctx: CallPointerMessageContext = { scenario: 'started', phoneNumber: '+15551234567' };
-    const result = await composeCallPointerMessageGenerative(ctx, {}, generator);
-    // NODE_ENV is 'test' during bun test
-    expect(result).toContain('Call to +15551234567 started');
-  });
-
-  test('returns fallback when no generator provided', async () => {
-    const ctx: CallPointerMessageContext = { scenario: 'failed', phoneNumber: '+15559876543', reason: 'busy' };
-    const result = await composeCallPointerMessageGenerative(ctx);
-    expect(result).toContain('failed: busy');
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).not.toContain('Duration:');
+    expect(instruction).not.toContain('Reason:');
+    expect(instruction).not.toContain('Verification code:');
+    expect(instruction).not.toContain('Channel:');
   });
 
-  test('uses custom fallbackText when provided', async () => {
+  test('ends with generation instructions', () => {
     const ctx: CallPointerMessageContext = { scenario: 'completed', phoneNumber: '+15559876543' };
-    const result = await composeCallPointerMessageGenerative(ctx, { fallbackText: 'Custom fallback' });
-    expect(result).toBe('Custom fallback');
+    const instruction = buildPointerInstruction(ctx);
+    expect(instruction).toContain('Write a brief');
+    expect(instruction).toContain('Preserve all factual details');
   });
 });

package/src/__tests__/call-pointer-messages.test.ts

@@ -25,8 +25,8 @@ mock.module('../util/logger.js', () => ({
     }),
 }));
 
-import { addPointerMessage, formatDuration, resetPointerCopyGenerator, setPointerCopyGenerator } from '../calls/call-pointer-messages.js';
-import { getMessages } from '../memory/conversation-store.js';
+import { addPointerMessage, formatDuration, resetPointerMessageProcessor, setPointerMessageProcessor } from '../calls/call-pointer-messages.js';
+import { addMessage, getMessages } from '../memory/conversation-store.js';
 import { getDb, initializeDb, resetDb } from '../memory/db.js';
 import { conversations } from '../memory/schema.js';
 
@@ -95,7 +95,7 @@ describe('addPointerMessage', () => {
   });
 
   afterEach(() => {
-    resetPointerCopyGenerator();
+    resetPointerMessageProcessor();
   });
 
   afterAll(() => {
@@ -192,87 +192,149 @@ describe('addPointerMessage', () => {
     expect(text).toContain('failed: Max attempts exceeded');
   });
 
-  // Trust-aware tests: in test env, generator is not called (NODE_ENV=test
-  // short-circuits to fallback), so these validate the trust gating path
-  // while still receiving deterministic text.
+  // Trust-aware tests
 
-  test('untrusted audience uses deterministic fallback even with generator set', () => {
+  test('untrusted audience uses deterministic fallback even with processor set', () => {
     const convId = 'conv-ptr-untrusted';
-    // standard threadType + no origin channel = untrusted
     ensureConversation(convId, { threadType: 'standard' });
 
-    const generatorCalled = { value: false };
-    setPointerCopyGenerator(async () => {
-      generatorCalled.value = true;
-      return 'generated text';
+    const processorCalled = { value: false };
+    setPointerMessageProcessor(async () => {
+      processorCalled.value = true;
     });
 
     addPointerMessage(convId, 'started', '+15551234567');
     const text = getLatestAssistantText(convId);
-    // In test env, deterministic fallback is always used regardless of trust
     expect(text).toContain('Call to +15551234567 started');
+    // processor not called because standard threadType + no origin = untrusted
+    expect(processorCalled.value).toBe(false);
   });
 
-  test('explicit untrusted audience mode skips generator', () => {
+  test('explicit untrusted audience mode skips processor', () => {
     const convId = 'conv-ptr-explicit-untrusted';
     ensureConversation(convId, { threadType: 'private' });
 
-    const generatorCalled = { value: false };
-    setPointerCopyGenerator(async () => {
-      generatorCalled.value = true;
-      return 'generated text';
+    const processorCalled = { value: false };
+    setPointerMessageProcessor(async () => {
+      processorCalled.value = true;
     });
 
     addPointerMessage(convId, 'started', '+15551234567', undefined, 'untrusted');
     const text = getLatestAssistantText(convId);
     expect(text).toContain('Call to +15551234567 started');
-    // generator is not called because audience is explicitly untrusted
-    expect(generatorCalled.value).toBe(false);
+    expect(processorCalled.value).toBe(false);
   });
 
-  test('private threadType is detected as trusted audience', async () => {
-    const convId = 'conv-ptr-private';
+  test('trusted audience routes through daemon processor with required facts', async () => {
+    const convId = 'conv-ptr-trusted';
     ensureConversation(convId, { threadType: 'private' });
 
-    setPointerCopyGenerator(async () => 'generated text');
+    let capturedInstruction = '';
+    let capturedFacts: string[] = [];
+    setPointerMessageProcessor(async (_convId, instruction, requiredFacts) => {
+      capturedInstruction = instruction;
+      capturedFacts = requiredFacts ?? [];
+    });
 
     await addPointerMessage(convId, 'completed', '+15559876543', { duration: '1m' });
+    // Processor was called with a structured instruction
+    expect(capturedInstruction).toContain('[CALL_STATUS_EVENT]');
+    expect(capturedInstruction).toContain('+15559876543');
+    expect(capturedInstruction).toContain('completed');
+    expect(capturedInstruction).toContain('1m');
+    // Required facts include phone number, duration, and outcome keyword
+    expect(capturedFacts).toContain('+15559876543');
+    expect(capturedFacts).toContain('1m');
+    expect(capturedFacts).toContain('completed');
+  });
+
+  test('trusted audience falls back to deterministic on processor failure', async () => {
+    const convId = 'conv-ptr-processor-fail';
+    ensureConversation(convId, { threadType: 'private' });
+
+    setPointerMessageProcessor(async () => {
+      throw new Error('Daemon unavailable');
+    });
+
+    await addPointerMessage(convId, 'failed', '+15559876543', { reason: 'busy' });
+    // Falls back to deterministic — written directly to conversation store
     const text = getLatestAssistantText(convId);
-    // In test env, falls back to deterministic even on trusted path
-    expect(text).toContain('Call to +15559876543 completed (1m)');
+    expect(text).toContain('failed: busy');
   });
 
   test('vellum origin channel is detected as trusted audience', async () => {
     const convId = 'conv-ptr-vellum';
     ensureConversation(convId, { originChannel: 'vellum' });
 
-    setPointerCopyGenerator(async () => 'generated text');
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
+    });
 
     await addPointerMessage(convId, 'failed', '+15559876543', { reason: 'busy' });
-    const text = getLatestAssistantText(convId);
-    expect(text).toContain('failed: busy');
+    expect(processorCalled).toBe(true);
   });
 
   test('missing conversation defaults to untrusted', () => {
-    const _convId = 'conv-ptr-missing';
-    // Don't create the conversation — trust resolution should default to untrusted
+    const convId = 'conv-ptr-no-signals';
+    ensureConversation(convId);
+
+    const processorCalled = { value: false };
+    setPointerMessageProcessor(async () => {
+      processorCalled.value = true;
+    });
+
+    addPointerMessage(convId, 'started', '+15551234567');
+    const text = getLatestAssistantText(convId);
+    expect(text).toContain('Call to +15551234567 started');
+    expect(processorCalled.value).toBe(false);
+  });
+
+  // Provenance trust class tests
+
+  test('guardian provenance trust class is detected as trusted audience', async () => {
+    const convId = 'conv-ptr-guardian-provenance';
+    ensureConversation(convId, { threadType: 'standard' });
+    // Add a user message with guardian provenance metadata
+    await addMessage(convId, 'user', 'hello', { provenanceTrustClass: 'guardian' });
+
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
+    });
+
+    await addPointerMessage(convId, 'completed', '+15559876543');
+    expect(processorCalled).toBe(true);
+  });
 
-    const generatorCalled = { value: false };
-    setPointerCopyGenerator(async () => {
-      generatorCalled.value = true;
-      return 'generated text';
+  test('trusted_contact provenance trust class is detected as trusted audience', async () => {
+    const convId = 'conv-ptr-tc-provenance';
+    ensureConversation(convId, { threadType: 'standard' });
+    // Add a user message with trusted_contact provenance metadata
+    await addMessage(convId, 'user', 'hello', { provenanceTrustClass: 'trusted_contact' });
+
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
     });
 
-    // This will fail at addMessage because conversation doesn't exist,
-    // but the trust check itself should not throw. Test just the trust
-    // gating by using a conversation that exists but has no trust signals.
-    const convId2 = 'conv-ptr-no-signals';
-    ensureConversation(convId2);
+    await addPointerMessage(convId, 'completed', '+15559876543');
+    expect(processorCalled).toBe(true);
+  });
+
+  test('unknown provenance trust class does not grant trusted audience', () => {
+    const convId = 'conv-ptr-unknown-provenance';
+    ensureConversation(convId, { threadType: 'standard' });
+    addMessage(convId, 'user', 'hello', { provenanceTrustClass: 'unknown' });
 
-    addPointerMessage(convId2, 'started', '+15551234567');
-    const text = getLatestAssistantText(convId2);
+    const processorCalled = { value: false };
+    setPointerMessageProcessor(async () => {
+      processorCalled.value = true;
+    });
+
+    addPointerMessage(convId, 'started', '+15551234567');
+    const text = getLatestAssistantText(convId);
     expect(text).toContain('Call to +15551234567 started');
-    // generator not called because standard threadType + no origin = untrusted
-    expect(generatorCalled.value).toBe(false);
+    expect(processorCalled.value).toBe(false);
   });
 });