vellum 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vellum",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"

package/src/__tests__/__snapshots__/ipc-snapshot.test.ts.snap

@@ -87,6 +87,13 @@ exports[`IPC message snapshots ClientMessage types model_set serializes to expec
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types image_gen_model_set serializes to expected JSON 1`] = `
+{
+  "model": "gemini-2.5-flash-image",
+  "type": "image_gen_model_set",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types history_request serializes to expected JSON 1`] = `
 {
   "sessionId": "sess-001",
@@ -688,6 +695,13 @@ exports[`IPC message snapshots ClientMessage types work_item_complete serializes
 }
 `;
 
+exports[`IPC message snapshots ClientMessage types work_item_delete serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "type": "work_item_delete",
+}
+`;
+
 exports[`IPC message snapshots ClientMessage types work_item_run_task serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -2017,6 +2031,14 @@ exports[`IPC message snapshots ServerMessage types work_item_update_response ser
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types work_item_delete_response serializes to expected JSON 1`] = `
+{
+  "id": "wi-001",
+  "success": true,
+  "type": "work_item_delete_response",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types work_item_run_task_response serializes to expected JSON 1`] = `
 {
   "id": "wi-001",
@@ -2042,6 +2064,12 @@ exports[`IPC message snapshots ServerMessage types work_item_status_changed seri
 }
 `;
 
+exports[`IPC message snapshots ServerMessage types tasks_changed serializes to expected JSON 1`] = `
+{
+  "type": "tasks_changed",
+}
+`;
+
 exports[`IPC message snapshots ServerMessage types open_tasks_window serializes to expected JSON 1`] = `
 {
   "type": "open_tasks_window",

package/src/__tests__/app-bundler.test.ts

@@ -1,5 +1,4 @@
 import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
-import { createHash } from 'node:crypto';
 
 // Mock the logger before importing the module under test
 mock.module('../util/logger.js', () => ({
@@ -11,27 +10,6 @@ mock.module('../util/logger.js', () => ({
 
 import { extractRemoteUrls, materializeAssets } from '../bundler/app-bundler.js';
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Compute expected asset filename for a URL (mirrors the production logic). */
-function expectedFilename(url: string): string {
-  const hash = createHash('sha256').update(url).digest('hex').slice(0, 12);
-  let ext = '';
-  try {
-    const parsed = new URL(url);
-    const match = parsed.pathname.match(/\.\w+$/);
-    ext = match ? match[0] : '';
-  } catch {
-    // no extension
-  }
-  if (!ext || ext.length > 10 || !/^\.\w+$/.test(ext)) {
-    ext = '';
-  }
-  return `${hash}${ext}`;
-}
-
 // ---------------------------------------------------------------------------
 // extractRemoteUrls
 // ---------------------------------------------------------------------------
@@ -167,10 +145,9 @@ describe('materializeAssets', () => {
     const html = `<img src="${imageUrl}">`;
     const result = await materializeAssets(html);
 
-    const filename = expectedFilename(imageUrl);
-    expect(result.rewrittenHtml).toBe(`<img src="assets/${filename}">`);
+    expect(result.rewrittenHtml).toBe('<img src="assets/e724846245db.png">');
     expect(result.assets).toHaveLength(1);
-    expect(result.assets[0].archivePath).toBe(`assets/${filename}`);
+    expect(result.assets[0].archivePath).toBe('assets/e724846245db.png');
     expect(result.assets[0].data).toEqual(imageData);
   });
 
@@ -193,9 +170,14 @@ describe('materializeAssets', () => {
     const result = await materializeAssets(html);
 
     expect(result.assets).toHaveLength(3);
+
+    const expectedFilenames: Record<string, string> = {
+      'https://cdn.example.com/a.png': '6155f67efa62.png',
+      'https://cdn.example.com/b.css': '5e6d8d571910.css',
+      'https://cdn.example.com/c.js': '20fb1ea9b4c9.js',
+    };
     for (const url of urls) {
-      const filename = expectedFilename(url);
-      expect(result.rewrittenHtml).toContain(`assets/${filename}`);
+      expect(result.rewrittenHtml).toContain(`assets/${expectedFilenames[url]}`);
       expect(result.rewrittenHtml).not.toContain(url);
     }
   });
@@ -242,8 +224,7 @@ describe('materializeAssets', () => {
     const html = `<img src="${goodUrl}"><img src="${badUrl}">`;
     const result = await materializeAssets(html);
 
-    const goodFilename = expectedFilename(goodUrl);
-    expect(result.rewrittenHtml).toContain(`assets/${goodFilename}`);
+    expect(result.rewrittenHtml).toContain('assets/691e2a787421.png');
     expect(result.rewrittenHtml).toContain(badUrl);
     expect(result.assets).toHaveLength(1);
   });
@@ -265,9 +246,8 @@ describe('materializeAssets', () => {
     expect(result.assets).toHaveLength(1);
 
     // Both occurrences should be rewritten
-    const filename = expectedFilename(imageUrl);
     expect(result.rewrittenHtml).not.toContain(imageUrl);
-    const matches = result.rewrittenHtml.match(new RegExp(`assets/${filename}`, 'g'));
+    const matches = result.rewrittenHtml.match(/assets\/2f7fc0f99275\.png/g);
     expect(matches).toHaveLength(2);
   });
 
@@ -306,8 +286,7 @@ describe('materializeAssets', () => {
     const html = '<style>body { background: url("https://cdn.example.com/bg.jpg"); }</style>';
     const result = await materializeAssets(html);
 
-    const filename = expectedFilename(cssUrl);
-    expect(result.rewrittenHtml).toContain(`assets/${filename}`);
+    expect(result.rewrittenHtml).toContain('assets/8550eecd4975.jpg');
     expect(result.rewrittenHtml).not.toContain(cssUrl);
   });
 });

package/src/__tests__/browser-skill-endstate.test.ts

@@ -6,7 +6,7 @@
  */
 import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
 
-import { eagerModules, eagerModuleToolNames } from '../tools/tool-manifest.js';
+import { eagerModuleToolNames } from '../tools/tool-manifest.js';
 import {
   initializeTools,
   getAllTools,
@@ -52,10 +52,6 @@ describe('browser skill migration end-state', () => {
     }
   });
 
-  test('browser module is NOT in eagerModules', () => {
-    expect(eagerModules).not.toContain('./browser/headless-browser.js');
-  });
-
   test('browser tool names are NOT in eagerModuleToolNames', () => {
     for (const name of BROWSER_TOOLS) {
       expect(eagerModuleToolNames).not.toContain(name);

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

@@ -0,0 +1,328 @@
+import { describe, test, expect, beforeEach, afterAll, mock, type Mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { EventEmitter } from 'node:events';
+
+const testDir = mkdtempSync(join(tmpdir(), 'call-orchestrator-test-'));
+
+// ── Platform + logger mocks (must come before any source imports) ────
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Config mock ─────────────────────────────────────────────────────
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ apiKeys: { anthropic: 'test-key' } }),
+}));
+
+// ── Helpers for building mock streaming responses ───────────────────
+
+/**
+ * Creates a mock Anthropic stream object that emits 'text' events
+ * for each token and resolves `finalMessage()` with the full response.
+ */
+function createMockStream(tokens: string[]) {
+  const emitter = new EventEmitter();
+  const fullText = tokens.join('');
+
+  const stream = {
+    on: (event: string, handler: (...args: unknown[]) => void) => {
+      emitter.on(event, handler);
+      return stream;
+    },
+    finalMessage: () => {
+      // 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 stream;
+}
+
+// ── Anthropic SDK mock ──────────────────────────────────────────────
+
+let mockStreamFn: Mock<(...args: unknown[]) => unknown>;
+
+mock.module('@anthropic-ai/sdk', () => {
+  mockStreamFn = mock((..._args: unknown[]) => createMockStream(['Hello', ' there']));
+  return {
+    default: class MockAnthropic {
+      messages = {
+        stream: (...args: unknown[]) => mockStreamFn(...args),
+      };
+    },
+  };
+});
+
+// ── Import source modules after all mocks are registered ────────────
+
+import { initializeDb, getDb } from '../memory/db.js';
+import { conversations } from '../memory/schema.js';
+import {
+  createCallSession,
+  getCallSession,
+  getPendingQuestion,
+} from '../calls/call-store.js';
+import {
+  getCallOrchestrator,
+} from '../calls/call-state.js';
+import { CallOrchestrator } from '../calls/call-orchestrator.js';
+import type { RelayConnection } from '../calls/relay-server.js';
+
+initializeDb();
+
+afterAll(() => {
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+// ── RelayConnection mock factory ────────────────────────────────────
+
+interface MockRelay extends RelayConnection {
+  sentTokens: Array<{ token: string; last: boolean }>;
+  endCalled: boolean;
+  endReason: string | undefined;
+}
+
+function createMockRelay(): MockRelay {
+  const state = {
+    sentTokens: [] as Array<{ token: string; last: boolean }>,
+    _endCalled: false,
+    _endReason: undefined as string | undefined,
+  };
+
+  return {
+    get sentTokens() { return state.sentTokens; },
+    get endCalled() { return state._endCalled; },
+    get endReason() { return state._endReason; },
+    sendTextToken(token: string, last: boolean) {
+      state.sentTokens.push({ token, last });
+    },
+    endSession(reason?: string) {
+      state._endCalled = true;
+      state._endReason = reason;
+    },
+  } as unknown as MockRelay;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+let ensuredConvIds = new Set<string>();
+function ensureConversation(id: string): void {
+  if (ensuredConvIds.has(id)) return;
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations).values({
+    id,
+    title: `Test conversation ${id}`,
+    createdAt: now,
+    updatedAt: now,
+  }).run();
+  ensuredConvIds.add(id);
+}
+
+function resetTables() {
+  const db = getDb();
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM conversations');
+  ensuredConvIds = new Set();
+}
+
+/**
+ * Create a call session and an orchestrator wired to a mock relay.
+ */
+function setupOrchestrator(task?: string) {
+  ensureConversation('conv-orch-test');
+  const session = createCallSession({
+    conversationId: 'conv-orch-test',
+    provider: 'twilio',
+    fromNumber: '+15551111111',
+    toNumber: '+15552222222',
+    task,
+  });
+  const relay = createMockRelay();
+  const orchestrator = new CallOrchestrator(session.id, relay as unknown as RelayConnection, task ?? null);
+  return { session, relay, orchestrator };
+}
+
+describe('call-orchestrator', () => {
+  beforeEach(() => {
+    resetTables();
+    // Reset the stream mock to default behaviour
+    mockStreamFn.mockImplementation(() => createMockStream(['Hello', ' there']));
+  });
+
+  // ── handleCallerUtterance ─────────────────────────────────────────
+
+  test('handleCallerUtterance: streams tokens via sendTextToken', async () => {
+    mockStreamFn.mockImplementation(() => createMockStream(['Hi', ', how', ' are you?']));
+    const { relay, orchestrator } = setupOrchestrator();
+
+    await orchestrator.handleCallerUtterance('Hello');
+
+    // Verify tokens were sent to the relay
+    const nonEmptyTokens = relay.sentTokens.filter((t) => t.token.length > 0);
+    expect(nonEmptyTokens.length).toBeGreaterThan(0);
+    // The last token should have last=true (empty string token signaling end)
+    const lastToken = relay.sentTokens[relay.sentTokens.length - 1];
+    expect(lastToken.last).toBe(true);
+
+    orchestrator.destroy();
+  });
+
+  test('handleCallerUtterance: sends last=true at end of turn', async () => {
+    mockStreamFn.mockImplementation(() => createMockStream(['Simple response.']));
+    const { relay, orchestrator } = setupOrchestrator();
+
+    await orchestrator.handleCallerUtterance('Test');
+
+    // Find the final empty-string token that marks end of turn
+    const endMarkers = relay.sentTokens.filter((t) => t.last === true);
+    expect(endMarkers.length).toBeGreaterThanOrEqual(1);
+
+    orchestrator.destroy();
+  });
+
+  // ── ASK_USER pattern ──────────────────────────────────────────────
+
+  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 { session, relay, orchestrator } = setupOrchestrator('Book appointment');
+
+    await orchestrator.handleCallerUtterance('I need to schedule something');
+
+    // Verify a pending question was created
+    const question = getPendingQuestion(session.id);
+    expect(question).not.toBeNull();
+    expect(question!.questionText).toBe('What date works best?');
+    expect(question!.status).toBe('pending');
+
+    // Verify session status was updated to waiting_on_user
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe('waiting_on_user');
+
+    // The ASK_USER marker text should NOT appear in the relay tokens
+    const allText = relay.sentTokens.map((t) => t.token).join('');
+    expect(allText).not.toContain('[ASK_USER:');
+
+    orchestrator.destroy();
+  });
+
+  // ── 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]']),
+    );
+    const { session, relay, orchestrator } = setupOrchestrator();
+
+    await orchestrator.handleCallerUtterance('That is all, thanks');
+
+    // endSession should have been called
+    expect(relay.endCalled).toBe(true);
+
+    // Session status should be completed
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe('completed');
+    expect(updatedSession!.endedAt).not.toBeNull();
+
+    // The END_CALL marker text should NOT appear in the relay tokens
+    const allText = relay.sentTokens.map((t) => t.token).join('');
+    expect(allText).not.toContain('[END_CALL]');
+
+    orchestrator.destroy();
+  });
+
+  // ── handleUserAnswer ──────────────────────────────────────────────
+
+  test('handleUserAnswer: appends USER_ANSWERED to history and runs LLM', async () => {
+    // First utterance triggers ASK_USER
+    mockStreamFn.mockImplementation(() =>
+      createMockStream(['Hold on. [ASK_USER: 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[]) => {
+      // 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.']);
+    });
+
+    await orchestrator.handleUserAnswer('3pm tomorrow');
+
+    // Should have streamed a response for the answer
+    const tokensAfterAnswer = relay.sentTokens.filter((t) => t.token.includes('3pm'));
+    expect(tokensAfterAnswer.length).toBeGreaterThan(0);
+
+    orchestrator.destroy();
+  });
+
+  // ── handleInterrupt ───────────────────────────────────────────────
+
+  test('handleInterrupt: resets state to idle', () => {
+    const { orchestrator } = setupOrchestrator();
+
+    // Calling handleInterrupt should not throw
+    orchestrator.handleInterrupt();
+
+    orchestrator.destroy();
+  });
+
+  // ── destroy ───────────────────────────────────────────────────────
+
+  test('destroy: unregisters orchestrator', () => {
+    const { session, orchestrator } = setupOrchestrator();
+
+    // Orchestrator should be registered
+    expect(getCallOrchestrator(session.id)).toBeDefined();
+
+    orchestrator.destroy();
+
+    // After destroy, orchestrator should be unregistered
+    expect(getCallOrchestrator(session.id)).toBeUndefined();
+  });
+
+  test('destroy: can be called multiple times without error', () => {
+    const { orchestrator } = setupOrchestrator();
+
+    orchestrator.destroy();
+    // Second destroy should not throw
+    expect(() => orchestrator.destroy()).not.toThrow();
+  });
+});

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

@@ -0,0 +1,133 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+import {
+  registerCallQuestionNotifier,
+  unregisterCallQuestionNotifier,
+  fireCallQuestionNotifier,
+  registerCallCompletionNotifier,
+  unregisterCallCompletionNotifier,
+  fireCallCompletionNotifier,
+  registerCallOrchestrator,
+  unregisterCallOrchestrator,
+  getCallOrchestrator,
+} from '../calls/call-state.js';
+import type { CallOrchestrator } from '../calls/call-orchestrator.js';
+
+describe('call-state', () => {
+  // Clean up notifiers between tests
+  beforeEach(() => {
+    unregisterCallQuestionNotifier('test-conv');
+    unregisterCallCompletionNotifier('test-conv');
+    unregisterCallOrchestrator('test-session');
+  });
+
+  // ── Question notifiers ────────────────────────────────────────────
+
+  test('registerCallQuestionNotifier + fireCallQuestionNotifier: callback receives args', () => {
+    let receivedSessionId = '';
+    let receivedQuestion = '';
+
+    registerCallQuestionNotifier('test-conv', (callSessionId, question) => {
+      receivedSessionId = callSessionId;
+      receivedQuestion = question;
+    });
+
+    fireCallQuestionNotifier('test-conv', 'session-123', 'What is the date?');
+
+    expect(receivedSessionId).toBe('session-123');
+    expect(receivedQuestion).toBe('What is the date?');
+  });
+
+  test('unregisterCallQuestionNotifier: fire after unregister does nothing', () => {
+    let called = false;
+
+    registerCallQuestionNotifier('test-conv', () => {
+      called = true;
+    });
+
+    unregisterCallQuestionNotifier('test-conv');
+    fireCallQuestionNotifier('test-conv', 'session-123', 'Some question');
+
+    expect(called).toBe(false);
+  });
+
+  test('fireCallQuestionNotifier does nothing when no notifier is registered', () => {
+    // Should not throw
+    fireCallQuestionNotifier('unregistered-conv', 'session-1', 'question');
+  });
+
+  // ── Completion notifiers ──────────────────────────────────────────
+
+  test('registerCallCompletionNotifier + fireCallCompletionNotifier: callback receives callSessionId', () => {
+    let receivedSessionId = '';
+
+    registerCallCompletionNotifier('test-conv', (callSessionId) => {
+      receivedSessionId = callSessionId;
+    });
+
+    fireCallCompletionNotifier('test-conv', 'session-456');
+
+    expect(receivedSessionId).toBe('session-456');
+  });
+
+  test('unregisterCallCompletionNotifier: fire after unregister does nothing', () => {
+    let called = false;
+
+    registerCallCompletionNotifier('test-conv', () => {
+      called = true;
+    });
+
+    unregisterCallCompletionNotifier('test-conv');
+    fireCallCompletionNotifier('test-conv', 'session-456');
+
+    expect(called).toBe(false);
+  });
+
+  test('fireCallCompletionNotifier does nothing when no notifier is registered', () => {
+    // Should not throw
+    fireCallCompletionNotifier('unregistered-conv', 'session-1');
+  });
+
+  // ── Orchestrator registry ─────────────────────────────────────────
+
+  test('registerCallOrchestrator + getCallOrchestrator: retrieves orchestrator', () => {
+    const fakeOrchestrator = { id: 'fake-orch' } as unknown as CallOrchestrator;
+
+    registerCallOrchestrator('test-session', fakeOrchestrator);
+
+    const retrieved = getCallOrchestrator('test-session');
+    expect(retrieved).toBe(fakeOrchestrator);
+  });
+
+  test('unregisterCallOrchestrator: getCallOrchestrator returns undefined after unregister', () => {
+    const fakeOrchestrator = { id: 'fake-orch-2' } as unknown as CallOrchestrator;
+
+    registerCallOrchestrator('test-session', fakeOrchestrator);
+    unregisterCallOrchestrator('test-session');
+
+    const retrieved = getCallOrchestrator('test-session');
+    expect(retrieved).toBeUndefined();
+  });
+
+  test('getCallOrchestrator returns undefined for unregistered session', () => {
+    const retrieved = getCallOrchestrator('nonexistent-session');
+    expect(retrieved).toBeUndefined();
+  });
+
+  test('registering a new orchestrator for same session overwrites the previous one', () => {
+    const first = { id: 'first' } as unknown as CallOrchestrator;
+    const second = { id: 'second' } as unknown as CallOrchestrator;
+
+    registerCallOrchestrator('test-session', first);
+    registerCallOrchestrator('test-session', second);
+
+    const retrieved = getCallOrchestrator('test-session');
+    expect(retrieved).toBe(second);
+  });
+});