vellum 0.2.0 → 0.2.2

package/src/__tests__/reminder.test.ts

@@ -1,51 +1,33 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { initializeDb } from '../memory/db.js';
-import { getDb } from '../memory/db.js';
+import { afterAll, describe, test, expect, beforeEach } from 'bun:test';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { reminders } from '../memory/schema.js';
-import { reminderTool } from '../tools/reminder/reminder.js';
+import { executeReminderCreate, executeReminderList, executeReminderCancel } from '../tools/reminder/reminder.js';
 import { claimDueReminders } from '../tools/reminder/reminder-store.js';
 
 initializeDb();
 
-const dummyContext = {
-  workingDir: '/tmp',
-  sessionId: 'test-session',
-  conversationId: 'test-conversation',
-};
-
 function clearReminders() {
   getDb().delete(reminders).run();
 }
 
+afterAll(() => {
+  resetDb();
+});
+
 describe('reminder tool', () => {
   beforeEach(() => {
     clearReminders();
   });
 
-  // ── action validation ───────────────────────────────────────────────
-
-  test('rejects missing action', async () => {
-    const result = await reminderTool.execute({}, dummyContext);
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('action is required');
-  });
-
-  test('rejects unknown action', async () => {
-    const result = await reminderTool.execute({ action: 'explode' }, dummyContext);
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('Unknown action');
-  });
-
   // ── create ──────────────────────────────────────────────────────────
 
   test('create with valid future ISO timestamp succeeds', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: future,
       label: 'Call Sidd',
       message: 'Remember to call Sidd',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Reminder created');
@@ -55,48 +37,44 @@ describe('reminder tool', () => {
 
   test('create with past timestamp returns error', async () => {
     const past = new Date(Date.now() - 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: past,
       label: 'Too late',
       message: 'This is in the past',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('must be in the future');
   });
 
   test('create with invalid timestamp string returns error', async () => {
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: 'not-a-date',
       label: 'Bad date',
       message: 'This has a bad date',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Invalid timestamp');
   });
 
   test('create rejects non-ISO date formats like MM/DD/YYYY', async () => {
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: '03/04/2027',
       label: 'Ambiguous date',
       message: 'This format is locale-dependent',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Invalid timestamp');
   });
 
   test('create rejects ISO timestamp without timezone', async () => {
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: '2027-03-15T09:00:00',
       label: 'No timezone',
       message: 'Missing timezone offset',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Invalid timestamp');
@@ -106,12 +84,11 @@ describe('reminder tool', () => {
     const future = new Date(Date.now() + 120_000);
     const offset = '-05:00';
     const isoWithOffset = future.toISOString().replace('Z', offset);
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: isoWithOffset,
       label: 'With offset',
       message: 'Has explicit timezone',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Reminder created');
@@ -119,12 +96,11 @@ describe('reminder tool', () => {
 
   test('create defaults mode to notify', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: future,
       label: 'Default mode',
       message: 'Should be notify',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Mode: notify');
@@ -132,24 +108,22 @@ describe('reminder tool', () => {
 
   test('create with mode execute sets mode correctly', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: future,
       label: 'Execute mode',
       message: 'Should be execute',
       mode: 'execute',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Mode: execute');
   });
 
   test('create requires fire_at', async () => {
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       label: 'No fire_at',
       message: 'Missing fire_at',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('fire_at is required');
@@ -157,11 +131,10 @@ describe('reminder tool', () => {
 
   test('create requires label', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: future,
       message: 'Missing label',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('label is required');
@@ -169,11 +142,10 @@ describe('reminder tool', () => {
 
   test('create requires message', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const result = await reminderTool.execute({
-      action: 'create',
+    const result = executeReminderCreate({
       fire_at: future,
       label: 'No message',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('message is required');
@@ -182,21 +154,20 @@ describe('reminder tool', () => {
   // ── list ────────────────────────────────────────────────────────────
 
   test('list returns "No reminders found" when empty', async () => {
-    const result = await reminderTool.execute({ action: 'list' }, dummyContext);
+    const result = executeReminderList();
     expect(result.isError).toBe(false);
     expect(result.content).toContain('No reminders found');
   });
 
   test('list returns formatted reminders', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    await reminderTool.execute({
-      action: 'create',
+    executeReminderCreate({
       fire_at: future,
       label: 'Test reminder',
       message: 'Test message',
-    }, dummyContext);
+    });
 
-    const result = await reminderTool.execute({ action: 'list' }, dummyContext);
+    const result = executeReminderList();
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Test reminder');
     expect(result.content).toContain('pending');
@@ -206,32 +177,29 @@ describe('reminder tool', () => {
 
   test('cancel with valid pending reminder succeeds', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const createResult = await reminderTool.execute({
-      action: 'create',
+    const createResult = executeReminderCreate({
       fire_at: future,
       label: 'Cancel me',
       message: 'To be cancelled',
-    }, dummyContext);
+    });
 
     // Extract ID from the create result
     const idMatch = createResult.content.match(/ID: (.+)/);
     expect(idMatch).not.toBeNull();
     const id = idMatch![1].trim();
 
-    const result = await reminderTool.execute({
-      action: 'cancel',
+    const result = executeReminderCancel({
       reminder_id: id,
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain('cancelled');
   });
 
   test('cancel with nonexistent ID returns error', async () => {
-    const result = await reminderTool.execute({
-      action: 'cancel',
+    const result = executeReminderCancel({
       reminder_id: 'nonexistent',
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('not found');
@@ -239,12 +207,11 @@ describe('reminder tool', () => {
 
   test('cancel with already-fired reminder returns error', async () => {
     const future = new Date(Date.now() + 60_000).toISOString();
-    const createResult = await reminderTool.execute({
-      action: 'create',
+    const createResult = executeReminderCreate({
       fire_at: future,
       label: 'Fire then cancel',
       message: 'x',
-    }, dummyContext);
+    });
 
     const idMatch = createResult.content.match(/ID: (.+)/);
     const id = idMatch![1].trim();
@@ -252,10 +219,9 @@ describe('reminder tool', () => {
     // Force-fire by claiming with a future timestamp
     claimDueReminders(Date.now() + 120_000);
 
-    const result = await reminderTool.execute({
-      action: 'cancel',
+    const result = executeReminderCancel({
       reminder_id: id,
-    }, dummyContext);
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('not found or already fired');

package/src/__tests__/run-orchestrator-assistant-events.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Tests that HTTP-triggered run/session flows mirror messages into the
+ * assistant-events hub with payload parity to IPC outbound messages.
+ *
+ * The Session class has two distinct outbound paths:
+ *   1. updateClient handler — used by the prompter for confirmation_request,
+ *      trace emitter, secret prompter.
+ *   2. runAgentLoop onEvent callback — used for the primary streaming events:
+ *      assistant_text_delta, message_complete, tool_use_start, tool_result, etc.
+ *
+ * Both paths must publish to the hub.
+ *
+ * Tests:
+ *   - confirmation_request (updateClient path) → hub emits one AssistantEvent
+ *   - assistant_text_delta + message_complete (onEvent path) → hub emits in order
+ *   - sessionId falls back to conversationId when the message lacks it
+ */
+import { afterAll, describe, test, expect, beforeEach, mock } from 'bun:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ServerMessage } from '../daemon/ipc-protocol.js';
+import type { Session } from '../daemon/session.js';
+import type { AssistantEvent } from '../runtime/assistant-event.js';
+
+const testDir = mkdtempSync(join(tmpdir(), 'run-orch-hub-test-'));
+
+mock.module('../util/platform.js', () => ({
+  getRootDir: () => testDir,
+  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: () => () => {},
+  }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { createConversation } from '../memory/conversation-store.js';
+import { RunOrchestrator } from '../runtime/run-orchestrator.js';
+import { assistantEventHub } from '../runtime/assistant-event-hub.js';
+
+initializeDb();
+
+afterAll(() => {
+  resetDb();
+});
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Build a session that calls the updateClient handler with the given messages
+ * (simulates prompter / confirmation path).
+ */
+function makeSessionEmittingViaClient(...messages: ServerMessage[]): Session {
+  let clientHandler: (msg: ServerMessage) => void = () => {};
+  return {
+    isProcessing: () => false,
+    persistUserMessage: () => undefined as unknown as string,
+    setChannelCapabilities: () => {},
+    updateClient: (handler: (msg: ServerMessage) => void) => {
+      clientHandler = handler;
+    },
+    runAgentLoop: async () => {
+      for (const msg of messages) {
+        clientHandler(msg);
+      }
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+/**
+ * Build a session that calls the onEvent callback with the given messages
+ * (simulates the primary agent-loop streaming path).
+ */
+function makeSessionEmittingViaAgentLoop(...messages: ServerMessage[]): Session {
+  return {
+    isProcessing: () => false,
+    persistUserMessage: () => undefined as unknown as string,
+    setChannelCapabilities: () => {},
+    updateClient: () => {},
+    runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
+      for (const msg of messages) {
+        onEvent(msg);
+      }
+    },
+    handleConfirmationResponse: () => {},
+  } as unknown as Session;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('HTTP run → confirmation_request mirrors to assistant-events hub', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('confirmation_request (updateClient path) emits one AssistantEvent', async () => {
+    const conversation = createConversation('http-confirmation-test');
+    const confirmationMsg: ServerMessage = {
+      type: 'confirmation_request',
+      requestId: 'req-http-1',
+      toolName: 'bash',
+      input: { command: 'ls' },
+      riskLevel: 'medium',
+      allowlistOptions: [{ label: 'ls', description: 'List files', pattern: 'ls' }],
+      scopeOptions: [{ label: 'everywhere', scope: 'everywhere' }],
+    };
+    const session = makeSessionEmittingViaClient(confirmationMsg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'Do something');
+    // Wait for the async hub chain to flush.
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(1);
+    expect(received[0].assistantId).toBe('self');
+    expect(received[0].sessionId).toBe(conversation.id);
+    expect(received[0].message.type).toBe('confirmation_request');
+    expect(received[0].message).toBe(confirmationMsg);
+  });
+});
+
+describe('HTTP run → message flow mirrors to assistant-events hub', () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run('DELETE FROM message_runs');
+    db.run('DELETE FROM messages');
+    db.run('DELETE FROM conversations');
+  });
+
+  test('assistant_text_delta and message_complete (onEvent path) emit in order', async () => {
+    const conversation = createConversation('http-message-flow-test');
+    const deltaMsg: ServerMessage = {
+      type: 'assistant_text_delta',
+      sessionId: conversation.id,
+      text: 'Working on it...',
+    };
+    const completeMsg: ServerMessage = {
+      type: 'message_complete',
+      sessionId: conversation.id,
+    };
+    const session = makeSessionEmittingViaAgentLoop(deltaMsg, completeMsg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'Hello');
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(2);
+    expect(received[0].message.type).toBe('assistant_text_delta');
+    expect(received[1].message.type).toBe('message_complete');
+    // Both should carry the session id
+    expect(received[0].sessionId).toBe(conversation.id);
+    expect(received[1].sessionId).toBe(conversation.id);
+    // Messages are the unmodified originals
+    expect(received[0].message).toBe(deltaMsg);
+    expect(received[1].message).toBe(completeMsg);
+  });
+
+  test('sessionId falls back to conversationId when message lacks it (onEvent path)', async () => {
+    const conversation = createConversation('http-session-fallback-test');
+    // pong has no sessionId field
+    const msg: ServerMessage = { type: 'pong' };
+    const session = makeSessionEmittingViaAgentLoop(msg);
+
+    const received: AssistantEvent[] = [];
+    const sub = assistantEventHub.subscribe(
+      { assistantId: 'self' },
+      (e) => { received.push(e); },
+    );
+
+    const orchestrator = new RunOrchestrator({
+      getOrCreateSession: async () => session,
+      resolveAttachments: () => [],
+    });
+
+    await orchestrator.startRun(conversation.id, 'ping');
+    await new Promise((r) => setTimeout(r, 20));
+
+    sub.dispose();
+
+    expect(received).toHaveLength(1);
+    expect(received[0].sessionId).toBe(conversation.id);
+  });
+});

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

@@ -40,7 +40,7 @@ function makeSessionWithConfirmation(message: ServerMessage): Session {
     // Return undefined so createRun stores messageId as null and avoids
     // a foreign-key dependency on the conversation-store message table.
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },
@@ -60,7 +60,7 @@ function makeSessionWithEvent(message: ServerMessage): Session {
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       onEvent(message);
@@ -92,7 +92,7 @@ describe('run failure detection', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+    const run = await orchestrator.startRun(conversation.id, 'Hello');
 
     // The agent loop fires asynchronously; give it a tick to settle.
     await new Promise((r) => setTimeout(r, 50));
@@ -114,7 +114,7 @@ describe('run failure detection', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Hello');
+    const run = await orchestrator.startRun(conversation.id, 'Hello');
 
     await new Promise((r) => setTimeout(r, 50));
 
@@ -139,7 +139,7 @@ describe('run approval state executionTarget', () => {
 
   test('stores pending confirmation executionTarget when provided', () => {
     const conversation = createConversation('run test');
-    const run = createRun('assistant-1', conversation.id);
+    const run = createRun(conversation.id);
 
     setRunConfirmation(run.id, {
       toolName: 'host_file_read',
@@ -158,7 +158,7 @@ describe('run approval state executionTarget', () => {
 
   test('parses pending confirmations without executionTarget for legacy rows', () => {
     const conversation = createConversation('legacy run test');
-    const run = createRun('assistant-1', conversation.id);
+    const run = createRun(conversation.id);
 
     setRunConfirmation(run.id, {
       toolName: 'bash',
@@ -192,7 +192,7 @@ describe('run approval state executionTarget', () => {
       resolveAttachments: () => [],
     });
 
-    const run = await orchestrator.startRun('assistant-1', conversation.id, 'Run host command');
+    const run = await orchestrator.startRun(conversation.id, 'Run host command');
     const stored = orchestrator.getRun(run.id);
     expect(stored?.status).toBe('needs_confirmation');
     expect(stored?.pendingConfirmation?.executionTarget).toBe('host');