@vellumai/assistant 0.3.3 → 0.3.5

package/src/__tests__/user-reference.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { join } from 'node:path';
+
+const TEST_DIR = '/tmp/vellum-user-ref-test';
+
+mock.module('../util/platform.js', () => ({
+  getWorkspacePromptPath: (file: string) => join(TEST_DIR, file),
+}));
+
+// Mutable state the tests control
+let mockFileExists = false;
+let mockFileContent = '';
+
+mock.module('node:fs', () => ({
+  existsSync: (path: string) => {
+    if (path === join(TEST_DIR, 'USER.md')) return mockFileExists;
+    return false;
+  },
+  readFileSync: (path: string, _encoding: string) => {
+    if (path === join(TEST_DIR, 'USER.md') && mockFileExists) return mockFileContent;
+    throw new Error(`ENOENT: no such file: ${path}`);
+  },
+}));
+
+// Import after mocks are in place
+const { resolveUserReference } = await import('../config/user-reference.js');
+
+describe('resolveUserReference', () => {
+  beforeEach(() => {
+    mockFileExists = false;
+    mockFileContent = '';
+  });
+
+  test('returns "my human" when USER.md does not exist', () => {
+    mockFileExists = false;
+    expect(resolveUserReference()).toBe('my human');
+  });
+
+  test('returns "my human" when preferred name field is empty', () => {
+    mockFileExists = true;
+    mockFileContent = [
+      '## Onboarding Snapshot',
+      '',
+      '- Preferred name/reference:',
+      '- Goals:',
+      '- Locale:',
+    ].join('\n');
+    expect(resolveUserReference()).toBe('my human');
+  });
+
+  test('returns the configured name when it is set', () => {
+    mockFileExists = true;
+    mockFileContent = [
+      '## Onboarding Snapshot',
+      '',
+      '- Preferred name/reference: John',
+      '- Goals: ship fast',
+      '- Locale: en-US',
+    ].join('\n');
+    expect(resolveUserReference()).toBe('John');
+  });
+
+  test('trims whitespace around the configured name', () => {
+    mockFileExists = true;
+    mockFileContent = '- Preferred name/reference:   Alice   \n';
+    expect(resolveUserReference()).toBe('Alice');
+  });
+});

package/src/__tests__/web-search.test.ts

@@ -414,7 +414,7 @@ async function executeWebSearch(
 
   if (!apiKey) {
     return {
-      content: 'Error: No web search API key configured. Set PERPLEXITY_API_KEY or BRAVE_API_KEY environment variable, or configure a key in settings.',
+      content: 'Error: No web search API key configured. Provide a PERPLEXITY_API_KEY or BRAVE_API_KEY here in the chat using the secure credential prompt, or set it from the Settings page.',
       isError: true,
     };
   }

package/src/__tests__/work-item-output.test.ts

@@ -0,0 +1,110 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import type { Database } from 'bun:sqlite';
+import * as net from 'node:net';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const testDir = mkdtempSync(join(tmpdir(), 'work-item-output-test-'));
+
+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: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+mock.module('./indexer.js', () => ({
+  indexMessageNow: () => {},
+}));
+
+import { addMessage, createConversation } from '../memory/conversation-store.js';
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { createTask, createTaskRun, updateTaskRun } from '../tasks/task-store.js';
+import { createWorkItem, updateWorkItem } from '../work-items/work-item-store.js';
+import { handleWorkItemOutput } from '../daemon/handlers/work-items.js';
+import type { HandlerContext } from '../daemon/handlers/shared.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+  try { rmSync(testDir, { recursive: true, force: true }); } catch { /* best effort */ }
+});
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+describe('handleWorkItemOutput', () => {
+  beforeEach(() => {
+    const raw = getRawDb();
+    raw.run('DELETE FROM task_runs');
+    raw.run('DELETE FROM work_items');
+    raw.run('DELETE FROM tasks');
+    raw.run('DELETE FROM messages');
+    raw.run('DELETE FROM conversations');
+  });
+
+  test('uses only the latest assistant text block for summary output', () => {
+    const task = createTask({
+      title: 'Delete weather report',
+      template: 'Delete weather_report_task.txt',
+    });
+    const run = createTaskRun(task.id);
+    const item = createWorkItem({
+      taskId: task.id,
+      title: 'Delete weather_report_task.txt',
+    });
+    const conversation = createConversation('Task output test');
+
+    updateTaskRun(run.id, {
+      status: 'completed',
+      conversationId: conversation.id,
+      finishedAt: Date.now(),
+    });
+    updateWorkItem(item.id, {
+      status: 'awaiting_review',
+      lastRunId: run.id,
+      lastRunConversationId: conversation.id,
+      lastRunStatus: 'completed',
+    });
+
+    addMessage(conversation.id, 'assistant', JSON.stringify([
+      { type: 'text', text: "I'll need to delete the weather report file from your Documents folder. This will permanently remove it." },
+      { type: 'text', text: "Looks like that file has already been deleted — it's no longer there. I'll mark this task as done." },
+      { type: 'text', text: 'The file is already deleted, so the task is complete.' },
+    ]));
+
+    const sent: Array<{ type: string; [key: string]: unknown }> = [];
+    const socket = {} as net.Socket;
+    const ctx = {
+      send: (_socket: net.Socket, msg: { type: string; [key: string]: unknown }) => sent.push(msg),
+    } as unknown as HandlerContext;
+
+    handleWorkItemOutput({ type: 'work_item_output', id: item.id }, socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const response = sent[0];
+    expect(response.type).toBe('work_item_output_response');
+    expect(response.success).toBe(true);
+    expect((response.output as { summary: string }).summary).toBe('The file is already deleted, so the task is complete.');
+  });
+});

package/src/calls/call-domain.ts

@@ -51,6 +51,7 @@ export type StartCallInput = {
   task: string;
   context?: string;
   conversationId: string;
+  assistantId?: string;
   callerIdentityMode?: 'assistant_number' | 'user_number';
 };
 
@@ -87,7 +88,8 @@ export type CallerIdentityResult =
  * - If `requestedMode` is provided but overrides are disabled, return an error.
  * - Otherwise, always use `assistant_number` (implicit default).
  *
- * For `assistant_number`: uses the Twilio phone number from `getTwilioConfig()`.
+ * For `assistant_number`: uses the Twilio phone number from
+ *   `getTwilioConfig(assistantId)` so multi-assistant mappings are honored.
  *   No eligibility check is performed — this is a fast path.
  * For `user_number`: uses `config.calls.callerIdentity.userNumber` or the
  *   secure key `credential:twilio:user_phone_number`, then validates that the
@@ -96,6 +98,7 @@ export type CallerIdentityResult =
 export async function resolveCallerIdentity(
   config: AssistantConfig,
   requestedMode?: 'assistant_number' | 'user_number',
+  assistantId?: string,
 ): Promise<CallerIdentityResult> {
   const identityConfig = config.calls.callerIdentity;
   let mode: 'assistant_number' | 'user_number';
@@ -118,8 +121,8 @@ export async function resolveCallerIdentity(
   }
 
   if (mode === 'assistant_number') {
-    const twilioConfig = getTwilioConfig();
-    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber }, 'Resolved caller identity');
+    const twilioConfig = getTwilioConfig(assistantId);
+    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber, assistantId }, 'Resolved caller identity');
     return { ok: true, mode, fromNumber: twilioConfig.phoneNumber, source };
   }
 
@@ -175,7 +178,7 @@ export async function resolveCallerIdentity(
  * Initiate a new outbound call.
  */
 export async function startCall(input: StartCallInput): Promise<StartCallResult | CallError> {
-  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode } = input;
+  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode, assistantId = 'self' } = input;
 
   if (!phoneNumber || typeof phoneNumber !== 'string') {
     return { ok: false, error: 'phone_number is required and must be a string', status: 400 };
@@ -204,7 +207,7 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     const provider = new TwilioConversationRelayProvider();
 
     // Resolve which phone number to use as caller ID
-    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode);
+    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode, assistantId);
     if (!identityResult.ok) {
       return { ok: false, error: identityResult.error, status: 400 };
     }

package/src/calls/call-orchestrator.ts

@@ -8,6 +8,7 @@
 
 import Anthropic from '@anthropic-ai/sdk';
 import { getConfig } from '../config/loader.js';
+import { resolveUserReference } from '../config/user-reference.js';
 import { getLogger } from '../util/logger.js';
 import {
   getCallSession,
@@ -25,9 +26,21 @@ const log = getLogger('call-orchestrator');
 
 type OrchestratorState = 'idle' | 'processing' | 'waiting_on_user' | 'speaking';
 
-const ASK_USER_REGEX = /\[ASK_USER:\s*(.+?)\]/;
+const ASK_USER_CAPTURE_REGEX = /\[ASK_USER:\s*(.+?)\]/;
+const ASK_USER_MARKER_REGEX = /\[ASK_USER:\s*.+?\]/g;
+const USER_ANSWERED_MARKER_REGEX = /\[USER_ANSWERED:\s*.+?\]/g;
+const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
+const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
 const END_CALL_MARKER = '[END_CALL]';
 
+function stripInternalSpeechMarkers(text: string): string {
+  return text
+    .replace(ASK_USER_MARKER_REGEX, '')
+    .replace(USER_ANSWERED_MARKER_REGEX, '')
+    .replace(USER_INSTRUCTION_MARKER_REGEX, '')
+    .replace(END_CALL_MARKER_REGEX, '');
+}
+
 export class CallOrchestrator {
   private callSessionId: string;
   private relay: RelayConnection;
@@ -43,6 +56,8 @@ export class CallOrchestrator {
   private task: string | null;
   /** Instructions queued while an LLM turn is in-flight or during waiting_on_user */
   private pendingInstructions: string[] = [];
+  /** Monotonic run id used to suppress stale turn side effects after interruption. */
+  private llmRunVersion = 0;
 
   constructor(callSessionId: string, relay: RelayConnection, task: string | null) {
     this.callSessionId = callSessionId;
@@ -64,20 +79,30 @@ export class CallOrchestrator {
    * Handle a final caller utterance from the ConversationRelay.
    */
   async handleCallerUtterance(transcript: string, speaker?: PromptSpeakerContext): Promise<void> {
+    const interruptedInFlight = this.state === 'processing' || this.state === 'speaking';
     // If we're already processing or speaking, abort the in-flight generation
-    if (this.state === 'processing' || this.state === 'speaking') {
+    if (interruptedInFlight) {
       this.abortController.abort();
       this.abortController = new AbortController();
     }
 
     this.state = 'processing';
     this.resetSilenceTimer();
-
-    // Append caller utterance
-    this.conversationHistory.push({
-      role: 'user',
-      content: this.formatCallerUtterance(transcript, speaker),
-    });
+    const callerContent = this.formatCallerUtterance(transcript, speaker);
+
+    // Preserve strict role alternation for Anthropic. If the last message
+    // is already user-role (e.g. interrupted run never appended assistant,
+    // or a second caller prompt arrives before assistant completion), merge
+    // this utterance into that same user turn.
+    const lastMessage = this.conversationHistory[this.conversationHistory.length - 1];
+    if (lastMessage?.role === 'user') {
+      lastMessage.content = `${lastMessage.content}\n${callerContent}`;
+    } else {
+      this.conversationHistory.push({
+        role: 'user',
+        content: callerContent,
+      });
+    }
 
     await this.runLlm();
   }
@@ -168,8 +193,15 @@ export class CallOrchestrator {
    * Handle caller interrupting the assistant's speech.
    */
   handleInterrupt(): void {
+    const wasSpeaking = this.state === 'speaking';
     this.abortController.abort();
     this.abortController = new AbortController();
+    this.llmRunVersion++;
+    // Explicitly terminate the in-progress TTS turn so the relay can
+    // immediately hand control back to the caller after barge-in.
+    if (wasSpeaking) {
+      this.relay.sendTextToken('', true);
+    }
     this.state = 'idle';
   }
 
@@ -196,13 +228,14 @@ export class CallOrchestrator {
       : '1. Begin the conversation naturally.';
 
     return [
-      'You are on a live phone call on behalf of your user.',
+      `You are on a live phone call on behalf of ${resolveUserReference()}.`,
       this.task ? `Task: ${this.task}` : '',
       '',
       'You are speaking directly to the person who answered the phone.',
       'Respond naturally and conversationally — speak as you would in a real phone conversation.',
       '',
       'IMPORTANT RULES:',
+      '0. When introducing yourself, refer to yourself as an assistant. Avoid the phrase "AI assistant" unless directly asked.',
       disclosureRule,
       '2. Be concise — phone conversations should be brief and natural.',
       '3. If the callee asks something you don\'t know, include [ASK_USER: your question here] in your response along with a hold message like "Let me check on that for you."',
@@ -239,6 +272,8 @@ export class CallOrchestrator {
     }
 
     const client = new Anthropic({ apiKey });
+    const runVersion = ++this.llmRunVersion;
+    const runSignal = this.abortController.signal;
 
     try {
       this.state = 'speaking';
@@ -255,7 +290,7 @@ export class CallOrchestrator {
             content: m.content,
           })),
         },
-        { signal: this.abortController.signal },
+        { signal: runSignal },
       );
 
       // Buffer incoming tokens so we can strip control markers ([ASK_USER:...], [END_CALL])
@@ -264,6 +299,7 @@ export class CallOrchestrator {
       let ttsBuffer = '';
 
       const flushSafeText = (_force: boolean): void => {
+        if (!this.isCurrentRun(runVersion)) return;
         if (ttsBuffer.length === 0) return;
         const bracketIdx = ttsBuffer.indexOf('[');
         if (bracketIdx === -1) {
@@ -290,8 +326,12 @@ export class CallOrchestrator {
           const afterBracket = ttsBuffer;
           const couldBeControl =
             '[ASK_USER:'.startsWith(afterBracket) ||
+            '[USER_ANSWERED:'.startsWith(afterBracket) ||
+            '[USER_INSTRUCTION:'.startsWith(afterBracket) ||
             '[END_CALL]'.startsWith(afterBracket) ||
             afterBracket.startsWith('[ASK_USER:') ||
+            afterBracket.startsWith('[USER_ANSWERED:') ||
+            afterBracket.startsWith('[USER_INSTRUCTION:') ||
             afterBracket === '[END_CALL' ||
             afterBracket.startsWith('[END_CALL]');
 
@@ -312,23 +352,20 @@ export class CallOrchestrator {
       };
 
       stream.on('text', (text) => {
+        if (!this.isCurrentRun(runVersion)) return;
         ttsBuffer += text;
 
-        // If the buffer contains a complete control marker, strip it
-        if (ASK_USER_REGEX.test(ttsBuffer)) {
-          ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '');
-        }
-        if (ttsBuffer.includes(END_CALL_MARKER)) {
-          ttsBuffer = ttsBuffer.replace(END_CALL_MARKER, '');
-        }
+        // Remove complete control markers before text reaches TTS.
+        ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
 
         flushSafeText(false);
       });
 
       const finalMessage = await stream.finalMessage();
+      if (!this.isCurrentRun(runVersion)) return;
 
       // Final sweep: strip any remaining control markers from the buffer
-      ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '').replace(END_CALL_MARKER, '');
+      ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
       if (ttsBuffer.length > 0) {
         this.relay.sendTextToken(ttsBuffer, false);
       }
@@ -345,7 +382,7 @@ export class CallOrchestrator {
       // Record the assistant response
       this.conversationHistory.push({ role: 'assistant', content: responseText });
       recordCallEvent(this.callSessionId, 'assistant_spoke', { text: responseText });
-      const spokenText = responseText.replace(ASK_USER_REGEX, '').replace(END_CALL_MARKER, '').trim();
+      const spokenText = stripInternalSpeechMarkers(responseText).trim();
       if (spokenText.length > 0) {
         const session = getCallSession(this.callSessionId);
         if (session) {
@@ -354,7 +391,7 @@ export class CallOrchestrator {
       }
 
       // Check for ASK_USER pattern
-      const askMatch = responseText.match(ASK_USER_REGEX);
+      const askMatch = responseText.match(ASK_USER_CAPTURE_REGEX);
       if (askMatch) {
         const questionText = askMatch[1];
         createPendingQuestion(this.callSessionId, questionText);
@@ -412,8 +449,25 @@ export class CallOrchestrator {
       this.flushPendingInstructions();
     } catch (err: unknown) {
       // Aborted requests are expected (interruptions, rapid utterances)
-      if (err instanceof Error && err.name === 'AbortError') {
-        log.debug({ callSessionId: this.callSessionId }, 'LLM request aborted');
+      if (this.isExpectedAbortError(err) || runSignal.aborted) {
+        log.debug(
+          {
+            callSessionId: this.callSessionId,
+            errName: err instanceof Error ? err.name : typeof err,
+            stale: !this.isCurrentRun(runVersion),
+          },
+          'LLM request aborted',
+        );
+        if (this.isCurrentRun(runVersion)) {
+          this.state = 'idle';
+        }
+        return;
+      }
+      if (!this.isCurrentRun(runVersion)) {
+        log.debug(
+          { callSessionId: this.callSessionId, errName: err instanceof Error ? err.name : typeof err },
+          'Ignoring stale LLM streaming error from superseded turn',
+        );
         return;
       }
       log.error({ err, callSessionId: this.callSessionId }, 'LLM streaming error');
@@ -423,6 +477,15 @@ export class CallOrchestrator {
     }
   }
 
+  private isExpectedAbortError(err: unknown): boolean {
+    if (!(err instanceof Error)) return false;
+    return err.name === 'AbortError' || err.name === 'APIUserAbortError';
+  }
+
+  private isCurrentRun(runVersion: number): boolean {
+    return runVersion === this.llmRunVersion;
+  }
+
   /**
    * Drain any instructions that were queued while the LLM was active.
    * Each instruction is appended as a user message (now correctly after

package/src/calls/twilio-config.ts

@@ -13,20 +13,26 @@ export interface TwilioConfig {
   wssBaseUrl: string;
 }
 
-export function getTwilioConfig(): TwilioConfig {
-  const accountSid = getSecureKey('credential:twilio:account_sid');
-  const authToken = getSecureKey('credential:twilio:auth_token');
-  const config = loadConfig();
+function resolveTwilioPhoneNumber(assistantId: string | undefined, config: ReturnType<typeof loadConfig>): string {
+  if (assistantId) {
+    const assistantPhone = config.sms?.assistantPhoneNumbers?.[assistantId];
+    if (assistantPhone) {
+      return assistantPhone;
+    }
+  }
 
-  // Phone number resolution priority:
+  // Global fallback order:
   // 1. TWILIO_PHONE_NUMBER env var (explicit override)
   // 2. config file sms.phoneNumber (primary storage)
   // 3. credential:twilio:phone_number secure key (backward-compat fallback)
-  const phoneNumber =
-    process.env.TWILIO_PHONE_NUMBER ||
-    config.sms?.phoneNumber ||
-    getSecureKey('credential:twilio:phone_number') ||
-    '';
+  return process.env.TWILIO_PHONE_NUMBER || config.sms?.phoneNumber || getSecureKey('credential:twilio:phone_number') || '';
+}
+
+export function getTwilioConfig(assistantId?: string): TwilioConfig {
+  const accountSid = getSecureKey('credential:twilio:account_sid');
+  const authToken = getSecureKey('credential:twilio:auth_token');
+  const config = loadConfig();
+  const phoneNumber = resolveTwilioPhoneNumber(assistantId, config);
   const webhookBaseUrl = getPublicBaseUrl(config);
 
   // Always use the centralized relay URL derived from the public ingress base URL.
@@ -45,7 +51,7 @@ export function getTwilioConfig(): TwilioConfig {
     throw new Error('Twilio credentials not configured. Set credential:twilio:account_sid and credential:twilio:auth_token via the credential_store tool.');
   }
   if (!phoneNumber) {
-    throw new Error('TWILIO_PHONE_NUMBER not configured.');
+    throw new Error('Twilio phone number not configured.');
   }
 
   log.debug('Twilio config loaded successfully');