vellum 0.2.1 → 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

@@ -15,7 +15,7 @@
  *   - assistant_text_delta + message_complete (onEvent path) → hub emits in order
  *   - sessionId falls back to conversationId when the message lacks it
  */
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
+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';
@@ -44,13 +44,17 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+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 ──────────────────────────────────────────────────────────────────
 
 /**
@@ -62,7 +66,7 @@ function makeSessionEmittingViaClient(...messages: ServerMessage[]): Session {
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },
@@ -83,7 +87,7 @@ function makeSessionEmittingViaAgentLoop(...messages: ServerMessage[]): Session
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       for (const msg of messages) {

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);
@@ -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',

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -34,7 +34,7 @@ mock.module('../config/loader.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import * as conversationStore from '../memory/conversation-store.js';
 import { getOrCreateConversation } from '../memory/conversation-key-store.js';
 import {
@@ -46,6 +46,7 @@ import { RuntimeHttpServer } from '../runtime/http-server.js';
 initializeDb();
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });
 
@@ -82,7 +83,7 @@ describe('Runtime attachment metadata', () => {
     const conversationKey = 'test-conv-1';
 
     // Set up conversation and messages using "self" as the assistantId
-    const mapping = getOrCreateConversation("self", conversationKey);
+    const mapping = getOrCreateConversation(conversationKey);
     conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
     const assistantMsg = conversationStore.addMessage(
       mapping.conversationId,
@@ -91,7 +92,7 @@ describe('Runtime attachment metadata', () => {
     );
 
     // Upload and link an attachment using "self" as the assistantId
-    const stored = uploadAttachment("self", 'chart.png', 'image/png', 'iVBOR');
+    const stored = uploadAttachment('chart.png', 'image/png', 'iVBOR');
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
 
     const res = await fetch(
@@ -121,7 +122,7 @@ describe('Runtime attachment metadata', () => {
   test('GET /messages returns empty attachments when none linked', async () => {
     const conversationKey = 'test-conv-2';
 
-    const mapping = getOrCreateConversation("self", conversationKey);
+    const mapping = getOrCreateConversation(conversationKey);
     conversationStore.addMessage(mapping.conversationId, 'user', 'Hello');
     conversationStore.addMessage(
       mapping.conversationId,
@@ -142,7 +143,7 @@ describe('Runtime attachment metadata', () => {
   });
 
   test('GET /attachments/:id returns attachment with payload', async () => {
-    const stored = uploadAttachment("self", 'report.pdf', 'application/pdf', 'JVBER');
+    const stored = uploadAttachment('report.pdf', 'application/pdf', 'JVBER');
 
     const res = await fetch(
       `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,
@@ -162,7 +163,7 @@ describe('Runtime attachment metadata', () => {
   });
 
   test('GET /attachments/:id returns attachment stored under "self"', async () => {
-    const stored = uploadAttachment("self", 'shared.txt', 'text/plain', 'c2hhcmVk');
+    const stored = uploadAttachment('shared.txt', 'text/plain', 'c2hhcmVk');
 
     const res = await fetch(
       `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,

package/src/__tests__/runtime-runs-http.test.ts

@@ -58,7 +58,7 @@ function makeCompletingSession(): Session {
   return {
     isProcessing: () => processing,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async () => {
       processing = true;
@@ -73,7 +73,7 @@ function makeFailingSession(errorMsg: string): Session {
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       onEvent({ type: 'error', message: errorMsg });
@@ -87,7 +87,7 @@ function makeConfirmationSession(toolName: string): Session {
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },
@@ -113,7 +113,7 @@ function makeHangingSession(): Session {
   return {
     isProcessing: () => processing,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async () => {
       processing = true;

package/src/__tests__/runtime-runs.test.ts

@@ -48,7 +48,7 @@ function makeCompletingSession(): Session {
   return {
     isProcessing: () => processing,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async () => {
       processing = true;
@@ -66,7 +66,7 @@ function makeHangingSession(): Session {
   return {
     isProcessing: () => processing,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async () => {
       processing = true;
@@ -82,7 +82,7 @@ function makeFailingSession(errorMsg: string): Session {
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: () => {},
     runAgentLoop: async (_content: string, _messageId: string, onEvent: (msg: ServerMessage) => void) => {
       onEvent({ type: 'error', message: errorMsg });
@@ -97,7 +97,7 @@ function makeConfirmationSession(toolName: string, principal?: { kind?: string;
   return {
     isProcessing: () => false,
     persistUserMessage: () => undefined as unknown as string,
-    setAssistantId: () => {},
+    setChannelCapabilities: () => {},
     updateClient: (handler: (msg: ServerMessage) => void) => {
       clientHandler = handler;
     },