@vellumai/assistant 0.3.5 → 0.3.6

package/src/__tests__/approval-conversation-turn.test.ts

@@ -0,0 +1,214 @@
+import { describe, test, expect } from 'bun:test';
+import { runApprovalConversationTurn } from '../runtime/approval-conversation-turn.js';
+import type {
+  ApprovalConversationContext,
+  ApprovalConversationGenerator,
+  ApprovalConversationResult,
+} from '../runtime/http-types.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeContext(overrides: Partial<ApprovalConversationContext> = {}): ApprovalConversationContext {
+  return {
+    toolName: 'execute_shell',
+    allowedActions: ['approve_once', 'approve_always', 'reject'],
+    role: 'guardian',
+    pendingApprovals: [{ runId: 'run-1', toolName: 'execute_shell' }],
+    userMessage: 'yes, go ahead',
+    ...overrides,
+  };
+}
+
+function makeGenerator(result: ApprovalConversationResult): ApprovalConversationGenerator {
+  return async () => result;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('runApprovalConversationTurn', () => {
+  test('successful keep_pending response (non-decision message)', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext({ userMessage: 'what does this tool do?' }),
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'This tool runs shell commands. Would you like to approve it?',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toBe('This tool runs shell commands. Would you like to approve it?');
+    expect(result.targetRunId).toBeUndefined();
+  });
+
+  test('successful approve_once response', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved! Running the command now.',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('approve_once');
+    expect(result.replyText).toBe('Approved! Running the command now.');
+    expect(result.targetRunId).toBe('run-1');
+  });
+
+  test('successful reject response', async () => {
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      makeGenerator({
+        disposition: 'reject',
+        replyText: 'Request denied.',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('reject');
+    expect(result.replyText).toBe('Request denied.');
+  });
+
+  test('fail-closed on generator throwing an error', async () => {
+    const throwingGenerator: ApprovalConversationGenerator = async () => {
+      throw new Error('provider timeout');
+    };
+    const result = await runApprovalConversationTurn(makeContext(), throwingGenerator);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed on generator returning malformed output', async () => {
+    const malformedGenerator: ApprovalConversationGenerator = async () => {
+      // Return an object missing the required replyText
+      return { disposition: 'approve_once', replyText: '' } as ApprovalConversationResult;
+    };
+    const result = await runApprovalConversationTurn(makeContext(), malformedGenerator);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed on invalid disposition', async () => {
+    const badDisposition: ApprovalConversationGenerator = async () => {
+      return { disposition: 'yolo' as 'approve_once', replyText: 'Sure!' };
+    };
+    const result = await runApprovalConversationTurn(makeContext(), badDisposition);
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed when disposition is not in allowedActions', async () => {
+    // Context only allows approve_once and reject (no approve_always)
+    const restrictedContext = makeContext({
+      allowedActions: ['approve_once', 'reject'],
+    });
+
+    const result = await runApprovalConversationTurn(
+      restrictedContext,
+      makeGenerator({
+        disposition: 'approve_always',
+        replyText: 'Approved permanently!',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('keep_pending is always allowed regardless of allowedActions', async () => {
+    const restrictedContext = makeContext({
+      allowedActions: ['approve_once', 'reject'],
+    });
+
+    const result = await runApprovalConversationTurn(
+      restrictedContext,
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'Can you tell me more about this request?',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toBe('Can you tell me more about this request?');
+  });
+
+  test('fail-closed when single pending approval and hallucinated targetRunId', async () => {
+    // Only one pending approval, but model returns a non-matching targetRunId
+    const result = await runApprovalConversationTurn(
+      makeContext({
+        pendingApprovals: [{ runId: 'run-1', toolName: 'execute_shell' }],
+      }),
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-nonexistent',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('fail-closed when targetRunId does not match any pending approval', async () => {
+    const contextWithMultiple = makeContext({
+      pendingApprovals: [
+        { runId: 'run-1', toolName: 'execute_shell' },
+        { runId: 'run-2', toolName: 'file_write' },
+      ],
+    });
+
+    // Hallucinated run ID that doesn't match any pending approval
+    const result = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-nonexistent',
+      }),
+    );
+    expect(result.disposition).toBe('keep_pending');
+    expect(result.replyText).toContain("couldn't process");
+  });
+
+  test('targetRunId validation when multiple pending approvals', async () => {
+    const contextWithMultiple = makeContext({
+      pendingApprovals: [
+        { runId: 'run-1', toolName: 'execute_shell' },
+        { runId: 'run-2', toolName: 'file_write' },
+      ],
+    });
+
+    // Decision-bearing disposition without targetRunId should fail-close
+    const resultWithoutTarget = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        // no targetRunId
+      }),
+    );
+    expect(resultWithoutTarget.disposition).toBe('keep_pending');
+    expect(resultWithoutTarget.replyText).toContain("couldn't process");
+
+    // Decision-bearing disposition with targetRunId should succeed
+    const resultWithTarget = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'approve_once',
+        replyText: 'Approved!',
+        targetRunId: 'run-1',
+      }),
+    );
+    expect(resultWithTarget.disposition).toBe('approve_once');
+    expect(resultWithTarget.targetRunId).toBe('run-1');
+
+    // Non-decision disposition without targetRunId should pass through fine
+    const resultKeepPending = await runApprovalConversationTurn(
+      contextWithMultiple,
+      makeGenerator({
+        disposition: 'keep_pending',
+        replyText: 'Which request would you like to approve?',
+      }),
+    );
+    expect(resultKeepPending.disposition).toBe('keep_pending');
+  });
+});

package/src/__tests__/browser-manager.test.ts

@@ -34,6 +34,7 @@ function createMockPage(closed = false) {
     keyboard: { press: async () => {} },
     mouse: { click: async () => {}, move: async () => {}, wheel: async () => {} },
     bringToFront: async () => {},
+    on: () => {},
   };
 }
 

package/src/__tests__/call-conversation-messages.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect, beforeEach, afterAll, mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = mkdtempSync(join(tmpdir(), 'call-conversation-messages-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: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { conversations } from '../memory/schema.js';
+import { createCallSession, updateCallSession, recordCallEvent } from '../calls/call-store.js';
+import { getMessages } from '../memory/conversation-store.js';
+import { buildCallCompletionMessage, persistCallCompletionMessage } from '../calls/call-conversation-messages.js';
+
+initializeDb();
+
+function ensureConversation(id: string): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations).values({
+    id,
+    title: `Conversation ${id}`,
+    createdAt: now,
+    updatedAt: now,
+  }).run();
+}
+
+function resetTables(): void {
+  const db = getDb();
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM messages');
+  db.run('DELETE FROM conversations');
+}
+
+function getLatestAssistantText(conversationId: string): string {
+  const rows = getMessages(conversationId).filter((m) => m.role === 'assistant');
+  expect(rows.length).toBeGreaterThan(0);
+  const latest = rows[rows.length - 1];
+  const parsed = JSON.parse(latest.content) as Array<{ type: string; text?: string }>;
+  return parsed.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('');
+}
+
+describe('call-conversation-messages', () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  test('buildCallCompletionMessage labels failed calls correctly', () => {
+    const conversationId = 'conv-call-msg-failed';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'in_progress', startedAt: 1_000 });
+    updateCallSession(session.id, { status: 'failed', endedAt: 6_000 });
+    recordCallEvent(session.id, 'call_connected');
+    recordCallEvent(session.id, 'call_failed');
+
+    expect(buildCallCompletionMessage(session.id)).toBe('**Call failed** (5s). 2 event(s) recorded.');
+  });
+
+  test('buildCallCompletionMessage labels cancelled calls correctly', () => {
+    const conversationId = 'conv-call-msg-cancelled';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'in_progress', startedAt: 1_000 });
+    updateCallSession(session.id, { status: 'cancelled', endedAt: 4_000 });
+    recordCallEvent(session.id, 'call_connected');
+    recordCallEvent(session.id, 'call_ended');
+
+    expect(buildCallCompletionMessage(session.id)).toBe('**Call cancelled** (3s). 2 event(s) recorded.');
+  });
+
+  test('persistCallCompletionMessage keeps completed label when status is completed', () => {
+    const conversationId = 'conv-call-msg-completed';
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    updateCallSession(session.id, { status: 'completed' });
+    recordCallEvent(session.id, 'call_ended');
+
+    const summary = persistCallCompletionMessage(conversationId, session.id);
+    expect(summary).toBe('**Call completed**. 1 event(s) recorded.');
+    expect(getLatestAssistantText(conversationId)).toBe('**Call completed**. 1 event(s) recorded.');
+  });
+});