@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/fuzzy-match-property.test.ts

@@ -25,7 +25,7 @@ describe('fuzzy-match property-based tests', () => {
         fc.string({ minLength: 1, maxLength: 200 }),
         (content, target) => {
           const result = findMatch(content, target);
-          if (result !== null) {
+          if (result != null) {
             expect(result.similarity).toBeGreaterThanOrEqual(0);
             expect(result.similarity).toBeLessThanOrEqual(1);
           }
@@ -135,7 +135,7 @@ describe('fuzzy-match property-based tests', () => {
         fc.string({ minLength: 1, maxLength: 50 }),
         (content, target) => {
           const result = findMatch(content, target);
-          if (result !== null && result.method === 'exact') {
+          if (result != null && result.method === 'exact') {
             expect(content.includes(result.matched)).toBe(true);
             expect(content.slice(result.start, result.end)).toBe(result.matched);
           }
@@ -154,7 +154,7 @@ describe('fuzzy-match property-based tests', () => {
           const single = findMatch(content, target);
           const all = findAllMatches(content, target);
 
-          if (single === null) {
+          if (single == null) {
             expect(all.length).toBe(0);
           } else {
             expect(all.length).toBeGreaterThanOrEqual(1);
@@ -172,7 +172,7 @@ describe('fuzzy-match property-based tests', () => {
         fc.string({ minLength: 1, maxLength: 100 }),
         (content, target) => {
           const result = findMatch(content, target);
-          if (result !== null && result.similarity === 1) {
+          if (result != null && result.similarity === 1) {
             expect(['exact', 'whitespace']).toContain(result.method);
           }
         }
@@ -188,7 +188,7 @@ describe('fuzzy-match property-based tests', () => {
         fc.string({ minLength: 1, maxLength: 100 }),
         (content, target) => {
           const result = findMatch(content, target);
-          if (result !== null) {
+          if (result != null) {
             expect(result.start).toBeLessThanOrEqual(result.end);
           }
         }

package/src/__tests__/guardian-action-store.test.ts

@@ -0,0 +1,123 @@
+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(), 'guardian-action-store-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, createPendingQuestion } from '../calls/call-store.js';
+import {
+  createGuardianActionRequest,
+  createGuardianActionDelivery,
+  updateDeliveryStatus,
+  cancelGuardianActionRequest,
+  getGuardianActionRequest,
+  getDeliveriesByRequestId,
+} from '../memory/guardian-action-store.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 guardian_action_deliveries');
+  db.run('DELETE FROM guardian_action_requests');
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM conversations');
+}
+
+describe('guardian-action-store', () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  test('cancelGuardianActionRequest cancels both pending and sent deliveries', () => {
+    const conversationId = 'conv-guardian-cancel';
+    ensureConversation(conversationId);
+
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pendingQuestion = createPendingQuestion(session.id, 'What is our gate code?');
+
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: conversationId,
+      callSessionId: session.id,
+      pendingQuestionId: pendingQuestion.id,
+      questionText: pendingQuestion.questionText,
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const pendingDelivery = createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'macos',
+      destinationConversationId: 'conv-mac-guardian',
+    });
+    const sentDelivery = createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'telegram',
+      destinationChatId: 'chat-guardian',
+      destinationExternalUserId: 'guardian-user',
+    });
+    updateDeliveryStatus(sentDelivery.id, 'sent');
+
+    cancelGuardianActionRequest(request.id);
+
+    const updatedRequest = getGuardianActionRequest(request.id);
+    expect(updatedRequest).not.toBeNull();
+    expect(updatedRequest!.status).toBe('cancelled');
+
+    const deliveries = getDeliveriesByRequestId(request.id);
+    const pendingAfter = deliveries.find((d) => d.id === pendingDelivery.id);
+    const sentAfter = deliveries.find((d) => d.id === sentDelivery.id);
+    expect(pendingAfter?.status).toBe('cancelled');
+    expect(sentAfter?.status).toBe('cancelled');
+  });
+});

package/src/__tests__/guardian-action-sweep.test.ts

@@ -0,0 +1,277 @@
+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(), 'guardian-action-sweep-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: () => () => {},
+    }),
+}));
+
+const deliveredMessages: Array<{ url: string; body: Record<string, unknown> }> = [];
+
+mock.module('../runtime/gateway-client.js', () => ({
+  deliverChannelReply: async (url: string, body: Record<string, unknown>) => {
+    deliveredMessages.push({ url, body });
+  },
+}));
+
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
+import { conversations } from '../memory/schema.js';
+import { createCallSession, createPendingQuestion, getPendingQuestion } from '../calls/call-store.js';
+import {
+  createGuardianActionRequest,
+  createGuardianActionDelivery,
+  updateDeliveryStatus,
+  getGuardianActionRequest,
+  getDeliveriesByRequestId,
+} from '../memory/guardian-action-store.js';
+import {
+  sweepExpiredGuardianActions,
+  startGuardianActionSweep,
+  stopGuardianActionSweep,
+} from '../calls/guardian-action-sweep.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 guardian_action_deliveries');
+  db.run('DELETE FROM guardian_action_requests');
+  db.run('DELETE FROM call_pending_questions');
+  db.run('DELETE FROM call_events');
+  db.run('DELETE FROM call_sessions');
+  db.run('DELETE FROM messages');
+  db.run('DELETE FROM conversations');
+  deliveredMessages.length = 0;
+}
+
+describe('guardian-action-sweep', () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  afterAll(() => {
+    stopGuardianActionSweep();
+    resetDb();
+    try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  });
+
+  test('sweepExpiredGuardianActions expires requests past their expiresAt', () => {
+    const convId = 'conv-sweep-1';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'What is the code?');
+
+    // Create request that has already expired
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() - 10_000, // expired 10s ago
+    });
+
+    ensureConversation('conv-mac-1');
+    createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'macos',
+      destinationConversationId: 'conv-mac-1',
+    });
+    updateDeliveryStatus(
+      getDeliveriesByRequestId(request.id).find(d => d.destinationChannel === 'macos')!.id,
+      'sent',
+    );
+
+    sweepExpiredGuardianActions('http://localhost:3000');
+
+    const updatedRequest = getGuardianActionRequest(request.id);
+    expect(updatedRequest).not.toBeNull();
+    expect(updatedRequest!.status).toBe('expired');
+
+    const deliveries = getDeliveriesByRequestId(request.id);
+    expect(deliveries).toHaveLength(1);
+    expect(deliveries[0].status).toBe('expired');
+  });
+
+  test('sweepExpiredGuardianActions expires pending questions', () => {
+    const convId = 'conv-sweep-2';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'What is the gate code?');
+
+    createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() - 5_000,
+    });
+
+    // Verify the question is still pending before sweep
+    expect(getPendingQuestion(session.id)).not.toBeNull();
+
+    sweepExpiredGuardianActions('http://localhost:3000');
+
+    // Pending question should be expired
+    expect(getPendingQuestion(session.id)).toBeNull();
+  });
+
+  test('sweepExpiredGuardianActions does nothing when no expired requests exist', () => {
+    const convId = 'conv-sweep-3';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'Still valid?');
+
+    // Request that expires in the future
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() + 60_000, // expires in 60s
+    });
+
+    sweepExpiredGuardianActions('http://localhost:3000');
+
+    const updatedRequest = getGuardianActionRequest(request.id);
+    expect(updatedRequest!.status).toBe('pending');
+    expect(getPendingQuestion(session.id)).not.toBeNull();
+  });
+
+  test('sweepExpiredGuardianActions sends external channel expiry notices for sent deliveries', async () => {
+    const convId = 'conv-sweep-4';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'External question?');
+
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() - 5_000,
+    });
+
+    const delivery = createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'telegram',
+      destinationChatId: 'chat-123',
+    });
+    updateDeliveryStatus(delivery.id, 'sent');
+
+    sweepExpiredGuardianActions('http://localhost:3000');
+
+    // Wait for the fire-and-forget async delivery to complete
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // The external delivery should trigger an HTTP POST to the gateway
+    expect(deliveredMessages.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test('sweepExpiredGuardianActions skips failed deliveries', () => {
+    const convId = 'conv-sweep-5';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'Skip this?');
+
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() - 5_000,
+    });
+
+    const delivery = createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'telegram',
+      destinationChatId: 'chat-456',
+    });
+    updateDeliveryStatus(delivery.id, 'failed', 'Network error');
+
+    deliveredMessages.length = 0;
+
+    sweepExpiredGuardianActions('http://localhost:3000');
+
+    // Should NOT have sent an expiry notice for a failed delivery
+    expect(deliveredMessages).toHaveLength(0);
+  });
+
+  test('startGuardianActionSweep and stopGuardianActionSweep manage timer', () => {
+    startGuardianActionSweep('http://localhost:3000');
+    // Calling start again should be a no-op (idempotent)
+    startGuardianActionSweep('http://localhost:3000');
+
+    stopGuardianActionSweep();
+    // Calling stop again should be safe
+    stopGuardianActionSweep();
+  });
+});