@vellumai/assistant 0.3.4 → 0.3.6

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

@@ -2,7 +2,6 @@ import { describe, test, expect, beforeEach, afterAll, mock, type Mock } from 'b
 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(), 'call-orchestrator-test-'));
 
@@ -18,6 +17,7 @@ mock.module('../util/platform.js', () => ({
   getDbPath: () => join(testDir, 'test.db'),
   getLogPath: () => join(testDir, 'test.log'),
   ensureDataDir: () => {},
+  readHttpToken: () => null,
 }));
 
 mock.module('../util/logger.js', () => ({
@@ -38,9 +38,12 @@ mock.module('../config/user-reference.js', () => ({
 // ── Config mock ─────────────────────────────────────────────────────
 
 let mockCallModel: string | undefined = undefined;
+let mockDisclosure: { enabled: boolean; text: string } = { enabled: false, text: '' };
 
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
+    provider: 'anthropic',
+    providerOrder: ['anthropic'],
     apiKeys: { anthropic: 'test-key' },
     calls: {
       enabled: true,
@@ -49,58 +52,84 @@ mock.module('../config/loader.js', () => ({
       userConsultTimeoutSeconds: 90,
       userConsultationTimeoutSeconds: 90,
       silenceTimeoutSeconds: 30,
-      disclosure: { enabled: false, text: '' },
+      disclosure: mockDisclosure,
       safety: { denyCategories: [] },
       model: mockCallModel,
     },
+    memory: { enabled: false },
   }),
 }));
 
-// ── Helpers for building mock streaming responses ───────────────────
+// ── Helpers for building mock provider responses ────────────────────
 
 /**
- * Creates a mock Anthropic stream object that emits 'text' events
- * for each token and resolves `finalMessage()` with the full response.
+ * Creates a mock provider sendMessage implementation that emits text_delta
+ * events for each token and resolves with the full response.
  */
-function createMockStream(tokens: string[]) {
-  const emitter = new EventEmitter();
+function createMockProviderResponse(tokens: string[]) {
   const fullText = tokens.join('');
-
-  const stream = {
-    on: (event: string, handler: (...args: unknown[]) => void) => {
-      emitter.on(event, handler);
-      return stream;
-    },
-    finalMessage: () => {
-      // Emit tokens synchronously so the on('text') handler has fired
-      // before finalMessage resolves.
-      for (const token of tokens) {
-        emitter.emit('text', token);
-      }
-      return Promise.resolve({
-        content: [{ type: 'text', text: fullText }],
-      });
-    },
+  return async (
+    _messages: unknown[],
+    _tools: unknown[],
+    _systemPrompt: string,
+    options?: { onEvent?: (event: { type: string; text?: string }) => void; signal?: AbortSignal },
+  ) => {
+    // Emit text_delta events for each token
+    for (const token of tokens) {
+      options?.onEvent?.({ type: 'text_delta', text: token });
+    }
+    return {
+      content: [{ type: 'text', text: fullText }],
+      model: 'claude-sonnet-4-20250514',
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: 'end_turn',
+    };
   };
-
-  return stream;
 }
 
-// ── Anthropic SDK mock ──────────────────────────────────────────────
+// ── Provider registry mock ──────────────────────────────────────────
 
-let mockStreamFn: Mock<(...args: unknown[]) => unknown>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let mockSendMessage: Mock<any>;
 
-mock.module('@anthropic-ai/sdk', () => {
-  mockStreamFn = mock((..._args: unknown[]) => createMockStream(['Hello', ' there']));
+mock.module('../providers/registry.js', () => {
+  mockSendMessage = mock(createMockProviderResponse(['Hello', ' there']));
   return {
-    default: class MockAnthropic {
-      messages = {
-        stream: (...args: unknown[]) => mockStreamFn(...args),
+    listProviders: () => ['anthropic'],
+    getFailoverProvider: () => ({
+      name: 'anthropic',
+      sendMessage: (...args: unknown[]) => mockSendMessage(...args),
+    }),
+    getDefaultModel: (providerName: string) => {
+      const defaults: Record<string, string> = {
+        anthropic: 'claude-opus-4-6',
+        openai: 'gpt-5.2',
+        gemini: 'gemini-3-flash',
+        ollama: 'llama3.2',
+        fireworks: 'accounts/fireworks/models/kimi-k2p5',
+        openrouter: 'x-ai/grok-4',
       };
+      return defaults[providerName] ?? defaults.anthropic;
     },
   };
 });
 
+mock.module('../providers/provider-send-message.js', () => ({
+  resolveConfiguredProvider: () => ({
+    provider: {
+      name: 'anthropic',
+      sendMessage: (...args: unknown[]) => mockSendMessage(...args),
+    },
+    configuredProviderName: 'anthropic',
+    selectedProviderName: 'anthropic',
+    usedFallbackPrimary: false,
+  }),
+  getConfiguredProvider: () => ({
+    name: 'anthropic',
+    sendMessage: (...args: unknown[]) => mockSendMessage(...args),
+  }),
+}));
+
 // ── Import source modules after all mocks are registered ────────────
 
 import { initializeDb, getDb, resetDb } from '../memory/db.js';
@@ -176,9 +205,13 @@ function ensureConversation(id: string): void {
 
 function resetTables() {
   const db = getDb();
+  db.run('DELETE FROM guardian_action_deliveries');
+  db.run('DELETE FROM guardian_action_requests');
   db.run('DELETE FROM call_pending_questions');
   db.run('DELETE FROM call_events');
   db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM tool_invocations');
+  db.run('DELETE FROM messages');
   db.run('DELETE FROM conversations');
   ensuredConvIds = new Set();
 }
@@ -206,14 +239,15 @@ describe('call-orchestrator', () => {
     resetTables();
     mockCallModel = undefined;
     mockUserReference = 'my human';
-    // Reset the stream mock to default behaviour
-    mockStreamFn.mockImplementation(() => createMockStream(['Hello', ' there']));
+    mockDisclosure = { enabled: false, text: '' };
+    // Reset the provider mock to default behaviour
+    mockSendMessage.mockImplementation(createMockProviderResponse(['Hello', ' there']));
   });
 
   // ── handleCallerUtterance ─────────────────────────────────────────
 
   test('handleCallerUtterance: streams tokens via sendTextToken', async () => {
-    mockStreamFn.mockImplementation(() => createMockStream(['Hi', ', how', ' are you?']));
+    mockSendMessage.mockImplementation(createMockProviderResponse(['Hi', ', how', ' are you?']));
     const { relay, orchestrator } = setupOrchestrator();
 
     await orchestrator.handleCallerUtterance('Hello');
@@ -229,7 +263,7 @@ describe('call-orchestrator', () => {
   });
 
   test('handleCallerUtterance: sends last=true at end of turn', async () => {
-    mockStreamFn.mockImplementation(() => createMockStream(['Simple response.']));
+    mockSendMessage.mockImplementation(createMockProviderResponse(['Simple response.']));
     const { relay, orchestrator } = setupOrchestrator();
 
     await orchestrator.handleCallerUtterance('Test');
@@ -242,12 +276,18 @@ describe('call-orchestrator', () => {
   });
 
   test('handleCallerUtterance: includes speaker context in model message', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
-      const userMessage = firstArg.messages.find((m) => m.role === 'user');
-      expect(userMessage?.content).toContain('[SPEAKER id="speaker-1" label="Aaron" source="provider" confidence="0.91"]');
-      expect(userMessage?.content).toContain('Can you summarize this meeting?');
-      return createMockStream(['Sure, here is a summary.']);
+    mockSendMessage.mockImplementation(async (messages: unknown[], ..._rest: unknown[]) => {
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const userMessage = msgs.find((m) => m.role === 'user');
+      const userText = userMessage?.content?.[0]?.text ?? '';
+      expect(userText).toContain('[SPEAKER id="speaker-1" label="Aaron" source="provider" confidence="0.91"]');
+      expect(userText).toContain('Can you summarize this meeting?');
+      return {
+        content: [{ type: 'text', text: 'Sure, here is a summary.' }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -262,12 +302,89 @@ describe('call-orchestrator', () => {
     orchestrator.destroy();
   });
 
-  // ── ASK_USER pattern ──────────────────────────────────────────────
+  test('startInitialGreeting: generates model-driven opening and strips control marker from speech', async () => {
+    mockSendMessage.mockImplementation(async (messages: unknown[], ..._rest: unknown[]) => {
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const firstUser = msgs.find((m) => m.role === 'user');
+      expect(firstUser?.content?.[0]?.text).toContain('[CALL_OPENING]');
+      const tokens = ['Hi, I am calling about your appointment request. Is now a good time to talk?'];
+      const opts = _rest[2] as { onEvent?: (event: { type: string; text?: string }) => void } | undefined;
+      for (const token of tokens) {
+        opts?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
 
-  test('ASK_USER pattern: detects pattern, creates pending question, enters waiting_on_user', async () => {
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Let me check on that. ', '[ASK_USER: What date works best?]']),
-    );
+    const { relay, orchestrator } = setupOrchestrator('Confirm appointment');
+
+    const callCountBefore = mockSendMessage.mock.calls.length;
+    await orchestrator.startInitialGreeting();
+    await orchestrator.startInitialGreeting();
+
+    const allText = relay.sentTokens.map((t) => t.token).join('');
+    expect(allText).toContain('appointment request');
+    expect(allText).toContain('good time to talk');
+    expect(allText).not.toContain('[CALL_OPENING]');
+    expect(mockSendMessage.mock.calls.length - callCountBefore).toBe(1);
+
+    orchestrator.destroy();
+  });
+
+  test('startInitialGreeting: tags only the first caller response with CALL_OPENING_ACK', async () => {
+    let callCount = 0;
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      callCount++;
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const userMessages = msgs.filter((m) => m.role === 'user');
+      const lastUser = userMessages[userMessages.length - 1]?.content?.[0]?.text ?? '';
+
+      let tokens: string[];
+      if (callCount === 1) {
+        expect(lastUser).toContain('[CALL_OPENING]');
+        tokens = ['Hey Noa, it\'s Credence calling about your joke request. Is now okay for a quick one?'];
+      } else if (callCount === 2) {
+        expect(lastUser).toContain('[CALL_OPENING_ACK]');
+        expect(lastUser).toContain('Yeah. Sure. What\'s up?');
+        tokens = ['Great, here\'s one right away. Why did the scarecrow win an award?'];
+      } else {
+        expect(lastUser).not.toContain('[CALL_OPENING_ACK]');
+        expect(lastUser).toContain('Tell me the punchline');
+        tokens = ['Because he was outstanding in his field.'];
+      }
+
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator('Tell a joke immediately');
+
+    await orchestrator.startInitialGreeting();
+    await orchestrator.handleCallerUtterance('Yeah. Sure. What\'s up?');
+    await orchestrator.handleCallerUtterance('Tell me the punchline');
+
+    expect(callCount).toBe(3);
+
+    orchestrator.destroy();
+  });
+
+  // ── ASK_GUARDIAN pattern ──────────────────────────────────────────
+
+  test('ASK_GUARDIAN pattern: detects pattern, creates pending question, enters waiting_on_user', async () => {
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Let me check on that. ', '[ASK_GUARDIAN: What date works best?]'],
+    ));
     const { session, relay, orchestrator } = setupOrchestrator('Book appointment');
 
     await orchestrator.handleCallerUtterance('I need to schedule something');
@@ -282,9 +399,34 @@ describe('call-orchestrator', () => {
     const updatedSession = getCallSession(session.id);
     expect(updatedSession!.status).toBe('waiting_on_user');
 
-    // The ASK_USER marker text should NOT appear in the relay tokens
+    // The ASK_GUARDIAN marker text should NOT appear in the relay tokens
+    const allText = relay.sentTokens.map((t) => t.token).join('');
+    expect(allText).not.toContain('[ASK_GUARDIAN:');
+
+    orchestrator.destroy();
+  });
+
+  test('strips internal context markers from spoken output', async () => {
+    mockSendMessage.mockImplementation(createMockProviderResponse([
+      'Thanks for waiting. ',
+      '[USER_ANSWERED: The guardian said 3 PM works.] ',
+      '[USER_INSTRUCTION: Keep this short.] ',
+      '[CALL_OPENING_ACK] ',
+      'I can confirm 3 PM works.',
+    ]));
+    const { relay, orchestrator } = setupOrchestrator();
+
+    await orchestrator.handleCallerUtterance('Any update?');
+
     const allText = relay.sentTokens.map((t) => t.token).join('');
-    expect(allText).not.toContain('[ASK_USER:');
+    expect(allText).toContain('Thanks for waiting.');
+    expect(allText).toContain('I can confirm 3 PM works.');
+    expect(allText).not.toContain('[USER_ANSWERED:');
+    expect(allText).not.toContain('[USER_INSTRUCTION:');
+    expect(allText).not.toContain('[CALL_OPENING_ACK]');
+    expect(allText).not.toContain('USER_ANSWERED');
+    expect(allText).not.toContain('USER_INSTRUCTION');
+    expect(allText).not.toContain('CALL_OPENING_ACK');
 
     orchestrator.destroy();
   });
@@ -292,9 +434,9 @@ describe('call-orchestrator', () => {
   // ── END_CALL pattern ──────────────────────────────────────────────
 
   test('END_CALL pattern: detects marker, calls endSession, updates status to completed', async () => {
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Thank you for calling, goodbye! ', '[END_CALL]']),
-    );
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Thank you for calling, goodbye! ', '[END_CALL]'],
+    ));
     const { session, relay, orchestrator } = setupOrchestrator();
 
     await orchestrator.handleCallerUtterance('That is all, thanks');
@@ -317,21 +459,31 @@ describe('call-orchestrator', () => {
   // ── handleUserAnswer ──────────────────────────────────────────────
 
   test('handleUserAnswer: returns true immediately and fires LLM asynchronously', async () => {
-    // First utterance triggers ASK_USER
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Hold on. [ASK_USER: Preferred time?]']),
-    );
+    // First utterance triggers ASK_GUARDIAN
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Hold on. [ASK_GUARDIAN: Preferred time?]'],
+    ));
     const { relay, orchestrator } = setupOrchestrator();
 
     await orchestrator.handleCallerUtterance('I need an appointment');
 
     // Now provide the answer — reset mock for second LLM call
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
+    mockSendMessage.mockImplementation(async (messages: unknown[], ..._rest: unknown[]) => {
       // Verify the messages include the USER_ANSWERED marker
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
-      const lastUserMsg = firstArg.messages.filter((m: { role: string }) => m.role === 'user').pop();
-      expect(lastUserMsg?.content).toContain('[USER_ANSWERED: 3pm tomorrow]');
-      return createMockStream(['Great, I have scheduled for 3pm tomorrow.']);
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const lastUserMsg = msgs.filter((m) => m.role === 'user').pop();
+      expect(lastUserMsg?.content?.[0]?.text).toContain('[USER_ANSWERED: 3pm tomorrow]');
+      const tokens = ['Great, I have scheduled for 3pm tomorrow.'];
+      const opts = _rest[2] as { onEvent?: (event: { type: string; text?: string }) => void } | undefined;
+      for (const token of tokens) {
+        opts?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const accepted = await orchestrator.handleUserAnswer('3pm tomorrow');
@@ -352,9 +504,9 @@ describe('call-orchestrator', () => {
 
   test('mid-call question flow: unavailable time → ask user → user confirms → resumed call', async () => {
     // Step 1: Caller says "7:30" but it's unavailable. The LLM asks the user.
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['I\'m sorry, 7:30 is not available. ', '[ASK_USER: Is 8:00 okay instead?]']),
-    );
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['I\'m sorry, 7:30 is not available. ', '[ASK_GUARDIAN: Is 8:00 okay instead?]'],
+    ));
 
     const { session, relay, orchestrator } = setupOrchestrator('Schedule a haircut');
 
@@ -371,9 +523,9 @@ describe('call-orchestrator', () => {
     expect(midSession!.status).toBe('waiting_on_user');
 
     // Step 2: User answers "Yes, 8:00 works"
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Great, I\'ve booked you for 8:00. See you then! ', '[END_CALL]']),
-    );
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Great, I\'ve booked you for 8:00. See you then! ', '[END_CALL]'],
+    ));
 
     const accepted = await orchestrator.handleUserAnswer('Yes, 8:00 works for me');
     expect(accepted).toBe(true);
@@ -395,16 +547,9 @@ describe('call-orchestrator', () => {
   // ── Provider / LLM failure paths ───────────────────────────────
 
   test('LLM error: sends error message to caller and returns to idle', async () => {
-    // Make the stream throw an error on finalMessage
-    mockStreamFn.mockImplementation(() => {
-      const emitter = new EventEmitter();
-      return {
-        on: (event: string, handler: (...args: unknown[]) => void) => {
-          emitter.on(event, handler);
-          return { on: () => ({ on: () => ({}) }) };
-        },
-        finalMessage: () => Promise.reject(new Error('API rate limit exceeded')),
-      };
+    // Make sendMessage reject with an error
+    mockSendMessage.mockImplementation(async () => {
+      throw new Error('API rate limit exceeded');
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -424,19 +569,10 @@ describe('call-orchestrator', () => {
   });
 
   test('LLM APIUserAbortError: treats as expected abort without technical-issue fallback', async () => {
-    mockStreamFn.mockImplementation(() => {
-      const emitter = new EventEmitter();
-      return {
-        on: (event: string, handler: (...args: unknown[]) => void) => {
-          emitter.on(event, handler);
-          return { on: () => ({ on: () => ({}) }) };
-        },
-        finalMessage: () => {
-          const err = new Error('user abort');
-          err.name = 'APIUserAbortError';
-          return Promise.reject(err);
-        },
-      };
+    mockSendMessage.mockImplementation(async () => {
+      const err = new Error('user abort');
+      err.name = 'APIUserAbortError';
+      throw err;
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -451,22 +587,23 @@ describe('call-orchestrator', () => {
 
   test('stale superseded turn errors do not emit technical-issue fallback', async () => {
     let callCount = 0;
-    mockStreamFn.mockImplementation(() => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
       callCount++;
       if (callCount === 1) {
-        const emitter = new EventEmitter();
-        return {
-          on: (event: string, handler: (...args: unknown[]) => void) => {
-            emitter.on(event, handler);
-            return { on: () => ({ on: () => ({}) }) };
-          },
-          finalMessage: () =>
-            new Promise((_, reject) => {
-              setTimeout(() => reject(new Error('stale stream failure')), 20);
-            }),
-        };
+        return new Promise((_, reject) => {
+          setTimeout(() => reject(new Error('stale stream failure')), 20);
+        });
       }
-      return createMockStream(['Second turn response.']);
+      const tokens = ['Second turn response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -485,39 +622,102 @@ describe('call-orchestrator', () => {
     orchestrator.destroy();
   });
 
-  test('rapid caller barge-in coalesces contiguous user turns for role alternation', async () => {
+  test('barge-in cleanup never sends empty user turns to provider', async () => {
     let callCount = 0;
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void; signal?: AbortSignal }) => {
       callCount++;
+
+      // Initial outbound opener
       if (callCount === 1) {
-        const emitter = new EventEmitter();
-        const options = args[1] as { signal?: AbortSignal } | undefined;
+        const tokens = ['Hey Noa, this is Credence calling.'];
+        for (const token of tokens) {
+          options?.onEvent?.({ type: 'text_delta', text: token });
+        }
         return {
-          on: (event: string, handler: (...evtArgs: unknown[]) => void) => {
-            emitter.on(event, handler);
-            return { on: () => ({ on: () => ({}) }) };
-          },
-          finalMessage: () =>
-            new Promise((_, reject) => {
-              options?.signal?.addEventListener('abort', () => {
-                const err = new Error('aborted');
-                err.name = 'AbortError';
-                reject(err);
-              }, { once: true });
-            }),
+          content: [{ type: 'text', text: tokens.join('') }],
+          model: 'claude-sonnet-4-20250514',
+          usage: { inputTokens: 100, outputTokens: 50 },
+          stopReason: 'end_turn',
         };
       }
 
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
-      const roles = firstArg.messages.map((m) => m.role);
+      // First caller turn enters an in-flight LLM run that gets interrupted
+      if (callCount === 2) {
+        return new Promise((_, reject) => {
+          options?.signal?.addEventListener('abort', () => {
+            const err = new Error('aborted');
+            err.name = 'AbortError';
+            reject(err);
+          }, { once: true });
+        });
+      }
+
+      // Second caller turn should never include an empty user message.
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const userMessages = msgs.filter((m) => m.role === 'user');
+      expect(userMessages.length).toBeGreaterThan(0);
+      expect(userMessages.every((m) => m.content?.[0]?.text?.trim().length > 0)).toBe(true);
+      const tokens = ['Got it, thanks for clarifying.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { relay, orchestrator } = setupOrchestrator('Quick check-in');
+    await orchestrator.startInitialGreeting();
+
+    const firstTurnPromise = orchestrator.handleCallerUtterance('Hello?');
+    await new Promise((r) => setTimeout(r, 5));
+    const secondTurnPromise = orchestrator.handleCallerUtterance('What have you been up to lately?');
+
+    await Promise.all([firstTurnPromise, secondTurnPromise]);
+
+    const allTokens = relay.sentTokens.map((t) => t.token).join('');
+    expect(allTokens).toContain('Got it, thanks for clarifying.');
+    expect(allTokens).not.toContain('technical issue');
+
+    orchestrator.destroy();
+  });
+
+  test('rapid caller barge-in coalesces contiguous user turns for role alternation', async () => {
+    let callCount = 0;
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void; signal?: AbortSignal }) => {
+      callCount++;
+      if (callCount === 1) {
+        return new Promise((_, reject) => {
+          options?.signal?.addEventListener('abort', () => {
+            const err = new Error('aborted');
+            err.name = 'AbortError';
+            reject(err);
+          }, { once: true });
+        });
+      }
+
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const roles = msgs.map((m) => m.role);
       for (let i = 1; i < roles.length; i++) {
         expect(!(roles[i - 1] === 'user' && roles[i] === 'user')).toBe(true);
       }
-      const userMessages = firstArg.messages.filter((m) => m.role === 'user');
+      const userMessages = msgs.filter((m) => m.role === 'user');
       const lastUser = userMessages[userMessages.length - 1];
-      expect(lastUser?.content).toContain('First caller utterance');
-      expect(lastUser?.content).toContain('Second caller utterance');
-      return createMockStream(['Merged turn handled.']);
+      expect(lastUser?.content?.[0]?.text).toContain('First caller utterance');
+      expect(lastUser?.content?.[0]?.text).toContain('Second caller utterance');
+      const tokens = ['Merged turn handled.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -535,37 +735,37 @@ describe('call-orchestrator', () => {
 
   test('interrupt then next caller prompt still preserves role alternation', async () => {
     let callCount = 0;
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void; signal?: AbortSignal }) => {
       callCount++;
       if (callCount === 1) {
-        const emitter = new EventEmitter();
-        const options = args[1] as { signal?: AbortSignal } | undefined;
-        return {
-          on: (event: string, handler: (...evtArgs: unknown[]) => void) => {
-            emitter.on(event, handler);
-            return { on: () => ({ on: () => ({}) }) };
-          },
-          finalMessage: () =>
-            new Promise((_, reject) => {
-              options?.signal?.addEventListener('abort', () => {
-                const err = new Error('aborted');
-                err.name = 'AbortError';
-                reject(err);
-              }, { once: true });
-            }),
-        };
+        return new Promise((_, reject) => {
+          options?.signal?.addEventListener('abort', () => {
+            const err = new Error('aborted');
+            err.name = 'AbortError';
+            reject(err);
+          }, { once: true });
+        });
       }
 
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
-      const roles = firstArg.messages.map((m) => m.role);
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const roles = msgs.map((m) => m.role);
       for (let i = 1; i < roles.length; i++) {
         expect(!(roles[i - 1] === 'user' && roles[i] === 'user')).toBe(true);
       }
-      const userMessages = firstArg.messages.filter((m) => m.role === 'user');
+      const userMessages = msgs.filter((m) => m.role === 'user');
       const lastUser = userMessages[userMessages.length - 1];
-      expect(lastUser?.content).toContain('First caller utterance');
-      expect(lastUser?.content).toContain('Second caller utterance');
-      return createMockStream(['Post-interrupt response.']);
+      expect(lastUser?.content?.[0]?.text).toContain('First caller utterance');
+      expect(lastUser?.content?.[0]?.text).toContain('Second caller utterance');
+      const tokens = ['Post-interrupt response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -605,24 +805,18 @@ describe('call-orchestrator', () => {
   });
 
   test('handleInterrupt: increments llmRunVersion to suppress stale turn side effects', async () => {
-    // Use a stream whose finalMessage resolves immediately but whose
-    // continuation (the code after `await stream.finalMessage()`) will
-    // run asynchronously. This simulates the race where the promise
-    // microtask is queued right as handleInterrupt fires.
-    mockStreamFn.mockImplementation(() => {
-      const emitter = new EventEmitter();
+    // Use a sendMessage that resolves immediately but whose continuation
+    // (the code after `await provider.sendMessage()`) will run asynchronously.
+    // This simulates the race where the promise microtask is queued right
+    // as handleInterrupt fires.
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // Emit some tokens synchronously
+      options?.onEvent?.({ type: 'text_delta', text: 'Stale response that should be suppressed.' });
       return {
-        on: (event: string, handler: (...args: unknown[]) => void) => {
-          emitter.on(event, handler);
-          return { on: () => ({ on: () => ({}) }) };
-        },
-        finalMessage: () => {
-          // Emit some tokens synchronously
-          emitter.emit('text', 'Stale response that should be suppressed.');
-          return Promise.resolve({
-            content: [{ type: 'text', text: 'Stale response that should be suppressed.' }],
-          });
-        },
+        content: [{ type: 'text', text: 'Stale response that should be suppressed.' }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
       };
     });
 
@@ -631,7 +825,7 @@ describe('call-orchestrator', () => {
     // Start an LLM turn (don't await — we want to interrupt mid-flight)
     const turnPromise = orchestrator.handleCallerUtterance('Hello');
 
-    // Interrupt immediately. Because finalMessage resolves as a microtask,
+    // Interrupt immediately. Because sendMessage resolves as a microtask,
     // its continuation hasn't run yet. handleInterrupt increments
     // llmRunVersion so the continuation's isCurrentRun check will fail.
     orchestrator.handleInterrupt();
@@ -654,23 +848,14 @@ describe('call-orchestrator', () => {
   });
 
   test('handleInterrupt: sends turn terminator when interrupting active speech', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const emitter = new EventEmitter();
-      const options = args[1] as { signal?: AbortSignal } | undefined;
-      return {
-        on: (event: string, handler: (...evtArgs: unknown[]) => void) => {
-          emitter.on(event, handler);
-          return { on: () => ({ on: () => ({}) }) };
-        },
-        finalMessage: () =>
-          new Promise((_, reject) => {
-            options?.signal?.addEventListener('abort', () => {
-              const err = new Error('aborted');
-              err.name = 'AbortError';
-              reject(err);
-            }, { once: true });
-          }),
-      };
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void; signal?: AbortSignal }) => {
+      return new Promise((_, reject) => {
+        options?.signal?.addEventListener('abort', () => {
+          const err = new Error('aborted');
+          err.name = 'AbortError';
+          reject(err);
+        }, { once: true });
+      });
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -709,12 +894,22 @@ describe('call-orchestrator', () => {
 
   // ── Model override from config ──────────────────────────────────────
 
-  test('uses default model when calls.model is not set', async () => {
+  test('does not override model when calls.model is not set (preserves cross-provider failover)', async () => {
     mockCallModel = undefined;
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { model: string };
-      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
-      return createMockStream(['Default model response.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { config?: { model?: string }; onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // When calls.model is unset, no model override should be passed so each
+      // provider in the failover chain uses its own default model.
+      expect(options?.config?.model).toBeUndefined();
+      const tokens = ['Default model response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-opus-4-6',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -724,10 +919,18 @@ describe('call-orchestrator', () => {
 
   test('uses calls.model override from config when set', async () => {
     mockCallModel = 'claude-haiku-4-5-20251001';
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { model: string };
-      expect(firstArg.model).toBe('claude-haiku-4-5-20251001');
-      return createMockStream(['Override model response.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { config?: { model: string }; onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(options?.config?.model).toBe('claude-haiku-4-5-20251001');
+      const tokens = ['Override model response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-haiku-4-5-20251001',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -735,12 +938,21 @@ describe('call-orchestrator', () => {
     orchestrator.destroy();
   });
 
-  test('treats empty string calls.model as unset and falls back to default', async () => {
+  test('treats empty string calls.model as unset and omits model override', async () => {
     mockCallModel = '';
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { model: string };
-      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
-      return createMockStream(['Fallback model response.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { config?: { model?: string }; onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // Empty string is treated as unset — no model override
+      expect(options?.config?.model).toBeUndefined();
+      const tokens = ['Fallback model response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-opus-4-6',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -748,12 +960,21 @@ describe('call-orchestrator', () => {
     orchestrator.destroy();
   });
 
-  test('treats whitespace-only calls.model as unset and falls back to default', async () => {
+  test('treats whitespace-only calls.model as unset and omits model override', async () => {
     mockCallModel = '   ';
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { model: string };
-      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
-      return createMockStream(['Fallback model response.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { config?: { model?: string }; onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // Whitespace-only is treated as unset — no model override
+      expect(options?.config?.model).toBeUndefined();
+      const tokens = ['Fallback model response.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-opus-4-6',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -764,14 +985,23 @@ describe('call-orchestrator', () => {
   // ── handleUserInstruction ─────────────────────────────────────────
 
   test('handleUserInstruction: injects instruction marker into conversation history and triggers LLM when idle', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
-      const instructionMsg = firstArg.messages.find((m) =>
-        m.role === 'user' && m.content.includes('[USER_INSTRUCTION:'),
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const instructionMsg = msgs.find((m) =>
+        m.role === 'user' && m.content?.[0]?.text?.includes('[USER_INSTRUCTION:'),
       );
       expect(instructionMsg).toBeDefined();
-      expect(instructionMsg!.content).toContain('[USER_INSTRUCTION: Ask about their weekend plans]');
-      return createMockStream(['Sure, do you have any weekend plans?']);
+      expect(instructionMsg!.content[0].text).toContain('[USER_INSTRUCTION: Ask about their weekend plans]');
+      const tokens = ['Sure, do you have any weekend plans?'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { relay, orchestrator } = setupOrchestrator();
@@ -787,30 +1017,38 @@ describe('call-orchestrator', () => {
 
   test('handleUserInstruction: does not break existing answer flow', async () => {
     // Step 1: Caller says something, LLM responds normally
-    mockStreamFn.mockImplementation(() => createMockStream(['Hello! How can I help you today?']));
+    mockSendMessage.mockImplementation(createMockProviderResponse(['Hello! How can I help you today?']));
     const { session: _session, relay, orchestrator } = setupOrchestrator('Book appointment');
 
     await orchestrator.handleCallerUtterance('Hi there');
 
     // Step 2: Inject an instruction while idle
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { messages: Array<{ role: string; content: string }> };
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], _systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
       // Verify the history contains both the original exchange and the instruction
-      const messages = firstArg.messages;
-      expect(messages.length).toBeGreaterThanOrEqual(3); // user utterance + assistant response + instruction
-      const instructionMsg = messages.find((m) =>
-        m.role === 'user' && m.content.includes('[USER_INSTRUCTION:'),
+      expect(msgs.length).toBeGreaterThanOrEqual(3); // user utterance + assistant response + instruction
+      const instructionMsg = msgs.find((m) =>
+        m.role === 'user' && m.content?.[0]?.text?.includes('[USER_INSTRUCTION:'),
       );
       expect(instructionMsg).toBeDefined();
-      return createMockStream(['Of course, let me mention the weekend special.']);
+      const tokens = ['Of course, let me mention the weekend special.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     await orchestrator.handleUserInstruction('Mention the weekend special');
 
     // Step 3: Caller speaks again — the flow should continue normally
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Great choice! The weekend special is 20% off.']),
-    );
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Great choice! The weekend special is 20% off.'],
+    ));
 
     await orchestrator.handleCallerUtterance('Tell me more about that');
 
@@ -826,7 +1064,7 @@ describe('call-orchestrator', () => {
   });
 
   test('handleUserInstruction: emits user_instruction_relayed event', async () => {
-    mockStreamFn.mockImplementation(() => createMockStream(['Understood, adjusting approach.']));
+    mockSendMessage.mockImplementation(createMockProviderResponse(['Understood, adjusting approach.']));
 
     const { session, orchestrator } = setupOrchestrator();
 
@@ -843,20 +1081,25 @@ describe('call-orchestrator', () => {
   });
 
   test('handleUserInstruction: does not trigger LLM when orchestrator is not idle', async () => {
-    // First, trigger ASK_USER so orchestrator enters waiting_on_user
-    mockStreamFn.mockImplementation(() =>
-      createMockStream(['Hold on. [ASK_USER: What time?]']),
-    );
+    // First, trigger ASK_GUARDIAN so orchestrator enters waiting_on_user
+    mockSendMessage.mockImplementation(createMockProviderResponse(
+      ['Hold on. [ASK_GUARDIAN: What time?]'],
+    ));
 
     const { session, orchestrator } = setupOrchestrator();
     await orchestrator.handleCallerUtterance('I need an appointment');
     expect(orchestrator.getState()).toBe('waiting_on_user');
 
-    // Track how many times the stream mock is called
+    // Track how many times the provider mock is called
     let streamCallCount = 0;
-    mockStreamFn.mockImplementation(() => {
+    mockSendMessage.mockImplementation(async () => {
       streamCallCount++;
-      return createMockStream(['Response after instruction.']);
+      return {
+        content: [{ type: 'text', text: 'Response after instruction.' }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     // Inject instruction while in waiting_on_user state
@@ -876,10 +1119,18 @@ describe('call-orchestrator', () => {
   // ── System prompt: identity phrasing ────────────────────────────────
 
   test('system prompt contains resolved user reference (default)', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { system: string };
-      expect(firstArg.system).toContain('on behalf of my human');
-      return createMockStream(['Hello.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('on behalf of my human');
+      const tokens = ['Hello.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -889,10 +1140,18 @@ describe('call-orchestrator', () => {
 
   test('system prompt contains resolved user reference when set to a name', async () => {
     mockUserReference = 'John';
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { system: string };
-      expect(firstArg.system).toContain('on behalf of John');
-      return createMockStream(['Hello John\'s contact.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('on behalf of John');
+      const tokens = ['Hello John\'s contact.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -902,11 +1161,19 @@ describe('call-orchestrator', () => {
 
   test('system prompt does not hardcode "your user" in the opening line', async () => {
     mockUserReference = 'Alice';
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { system: string };
-      expect(firstArg.system).not.toContain('on behalf of your user');
-      expect(firstArg.system).toContain('on behalf of Alice');
-      return createMockStream(['Hi there.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).not.toContain('on behalf of your user');
+      expect(systemPrompt as string).toContain('on behalf of Alice');
+      const tokens = ['Hi there.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -915,11 +1182,40 @@ describe('call-orchestrator', () => {
   });
 
   test('system prompt includes assistant identity bias rule', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { system: string };
-      expect(firstArg.system).toContain('refer to yourself as an assistant');
-      expect(firstArg.system).toContain('Avoid the phrase "AI assistant" unless directly asked');
-      return createMockStream(['Sure thing.']);
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('refer to yourself as an assistant');
+      expect(systemPrompt as string).toContain('Avoid the phrase "AI assistant" unless directly asked');
+      const tokens = ['Sure thing.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hi');
+    orchestrator.destroy();
+  });
+
+  test('system prompt includes opening-ack guidance to avoid duplicate introductions', async () => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('[CALL_OPENING_ACK]');
+      expect(systemPrompt as string).toContain('without re-introducing yourself');
+      const tokens = ['Understood.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
@@ -928,19 +1224,273 @@ describe('call-orchestrator', () => {
   });
 
   test('assistant identity rule appears before disclosure rule in prompt', async () => {
-    mockStreamFn.mockImplementation((...args: unknown[]) => {
-      const firstArg = args[0] as { system: string };
-      const prompt = firstArg.system;
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      const prompt = systemPrompt as string;
       const identityIdx = prompt.indexOf('refer to yourself as an assistant');
       const disclosureIdx = prompt.indexOf('Be concise');
       expect(identityIdx).toBeGreaterThan(-1);
       expect(disclosureIdx).toBeGreaterThan(-1);
       expect(identityIdx).toBeLessThan(disclosureIdx);
-      return createMockStream(['OK.']);
+      const tokens = ['OK.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
     });
 
     const { orchestrator } = setupOrchestrator();
     await orchestrator.handleCallerUtterance('Test');
     orchestrator.destroy();
   });
+
+  test('system prompt uses disclosure text when disclosure is enabled', async () => {
+    mockDisclosure = {
+      enabled: true,
+      text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
+    };
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('introduce yourself as an assistant calling on behalf of the person you represent');
+      expect(systemPrompt as string).toContain('Do not say "AI assistant"');
+      const tokens = ['Hello, I am calling on behalf of my human.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Who is this?');
+    orchestrator.destroy();
+  });
+
+  test('system prompt falls back to "Begin the conversation naturally" when disclosure is disabled', async () => {
+    mockDisclosure = { enabled: false, text: '' };
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('Begin the conversation naturally');
+      expect(systemPrompt as string).not.toContain('introduce yourself as an assistant calling on behalf of the person');
+      const tokens = ['Hello there.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hi');
+    orchestrator.destroy();
+  });
+
+  test('system prompt does not use "AI assistant" as a self-identity label', async () => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).not.toMatch(/(?:you are|call yourself|introduce yourself as).*AI assistant/i);
+      const tokens = ['Got it.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hello');
+    orchestrator.destroy();
+  });
+
+  // ── Inbound call orchestration ──────────────────────────────────────
+
+  test('inbound call (no task) uses receptionist-style system prompt', async () => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // Should contain inbound-specific language
+      expect(systemPrompt as string).toContain('answering an incoming call');
+      expect(systemPrompt as string).toContain('find out what they need');
+      // Should NOT contain outbound-specific language
+      expect(systemPrompt as string).not.toContain('state why you are calling');
+      expect(systemPrompt as string).not.toContain('Task:');
+      const tokens = ['Hello, how can I help you today?'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    // setupOrchestrator with no task creates an inbound-style session
+    const { orchestrator } = setupOrchestrator(undefined);
+    await orchestrator.handleCallerUtterance('Hi there');
+    orchestrator.destroy();
+  });
+
+  test('outbound call (with task) uses task-driven system prompt', async () => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('Task: Confirm Friday appointment');
+      expect(systemPrompt as string).toContain('state why you are calling');
+      expect(systemPrompt as string).not.toContain('answering an incoming call');
+      const tokens = ['Hi, I am calling about your appointment.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator('Confirm Friday appointment');
+    await orchestrator.handleCallerUtterance('Hello?');
+    orchestrator.destroy();
+  });
+
+  test('inbound call initial greeting sends receptionist opener', async () => {
+    mockSendMessage.mockImplementation(async (messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // The system prompt should use inbound framing
+      expect(systemPrompt as string).toContain('answering an incoming call');
+      // The opening marker should be present
+      const msgs = messages as Array<{ role: string; content: Array<{ type: string; text: string }> }>;
+      const userMsgs = msgs.filter((m) => m.role === 'user');
+      expect(userMsgs.some((m) => m.content?.[0]?.text?.includes('[CALL_OPENING]'))).toBe(true);
+      const tokens = ['Hello, this is my human\'s assistant. How can I help you?'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { relay, orchestrator } = setupOrchestrator(undefined);
+    await orchestrator.startInitialGreeting();
+
+    const allText = relay.sentTokens.map((t) => t.token).join('');
+    expect(allText).toContain('How can I help you');
+
+    orchestrator.destroy();
+  });
+
+  test('inbound call multi-turn conversation uses inbound prompt consistently', async () => {
+    let turnNumber = 0;
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      turnNumber++;
+      // Every turn should use the inbound system prompt
+      expect(systemPrompt as string).toContain('answering an incoming call');
+      expect(systemPrompt as string).not.toContain('Task:');
+
+      let tokens: string[];
+      if (turnNumber === 1) tokens = ['Hello, how can I help you?'];
+      else if (turnNumber === 2) tokens = ['Sure, let me help with scheduling.'];
+      else tokens = ['Your meeting is set for 3pm.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator(undefined);
+
+    await orchestrator.startInitialGreeting();
+    await orchestrator.handleCallerUtterance('I need to schedule a meeting');
+    await orchestrator.handleCallerUtterance('How about 3pm?');
+
+    expect(turnNumber).toBe(3);
+    orchestrator.destroy();
+  });
+
+  test('inbound call system prompt includes greet-the-caller guidance for CALL_OPENING', async () => {
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      // Should tell the model to greet warmly and ask how to help
+      expect(systemPrompt as string).toContain('greet the caller warmly');
+      expect(systemPrompt as string).toContain('how you can help');
+      const tokens = ['Hello!'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator(undefined);
+    await orchestrator.handleCallerUtterance('Hi');
+    orchestrator.destroy();
+  });
+
+  test('inbound call system prompt respects disclosure setting', async () => {
+    mockDisclosure = {
+      enabled: true,
+      text: 'Disclose that you are an AI at the start.',
+    };
+    mockSendMessage.mockImplementation(async (_messages: unknown[], _tools: unknown[], systemPrompt: unknown, options?: { onEvent?: (event: { type: string; text?: string }) => void }) => {
+      expect(systemPrompt as string).toContain('answering an incoming call');
+      expect(systemPrompt as string).toContain('Disclose that you are an AI at the start.');
+      const tokens = ['Hello, I am an AI assistant.'];
+      for (const token of tokens) {
+        options?.onEvent?.({ type: 'text_delta', text: token });
+      }
+      return {
+        content: [{ type: 'text', text: tokens.join('') }],
+        model: 'claude-sonnet-4-20250514',
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: 'end_turn',
+      };
+    });
+
+    const { orchestrator } = setupOrchestrator(undefined);
+    await orchestrator.handleCallerUtterance('Who is this?');
+    orchestrator.destroy();
+  });
+
+  test('inbound call persists assistant response to voice conversation', async () => {
+    mockSendMessage.mockImplementation(createMockProviderResponse(['I can definitely help you with that.']));
+
+    const { session, orchestrator } = setupOrchestrator(undefined);
+    await orchestrator.startInitialGreeting();
+
+    // Verify assistant transcript was persisted
+    const messages = (await import('../memory/conversation-store.js')).getMessages('conv-orch-test');
+    const assistantMsgs = messages.filter((m) => m.role === 'assistant');
+    expect(assistantMsgs.length).toBeGreaterThan(0);
+    const lastAssistant = assistantMsgs[assistantMsgs.length - 1];
+    expect(lastAssistant.content).toContain('I can definitely help you with that');
+
+    // Verify event was recorded
+    const events = getCallEvents(session.id).filter((e) => e.eventType === 'assistant_spoke');
+    expect(events.length).toBeGreaterThan(0);
+
+    orchestrator.destroy();
+  });
 });