@vellumai/assistant 0.3.16 → 0.3.19

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

@@ -31,8 +31,16 @@ import {
   cancelGuardianActionRequest,
   createGuardianActionDelivery,
   createGuardianActionRequest,
+  expireGuardianActionRequest,
   getDeliveriesByRequestId,
+  getExpiredDeliveriesByConversation,
+  getExpiredDeliveryByConversation,
+  getFollowupDeliveriesByConversation,
+  getFollowupDeliveryByConversation,
   getGuardianActionRequest,
+  getPendingDeliveriesByConversation,
+  getPendingDeliveryByConversation,
+  startFollowupFromExpiredRequest,
   updateDeliveryStatus,
 } from '../memory/guardian-action-store.js';
 import { conversations } from '../memory/schema.js';
@@ -74,6 +82,180 @@ describe('guardian-action-store', () => {
     }
   });
 
+  // ── Helper to create a pending request+delivery targeting a conversation ──
+  function createPendingRequestWithDelivery(convId: string, deliveryConvId: string) {
+    ensureConversation(convId);
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, `Question for ${convId}`);
+    const request = createGuardianActionRequest({
+      kind: 'ask_guardian',
+      sourceChannel: 'voice',
+      sourceConversationId: convId,
+      callSessionId: session.id,
+      pendingQuestionId: pq.id,
+      questionText: pq.questionText,
+      expiresAt: Date.now() + 60_000,
+    });
+    const delivery = createGuardianActionDelivery({
+      requestId: request.id,
+      destinationChannel: 'vellum',
+      destinationConversationId: deliveryConvId,
+    });
+    updateDeliveryStatus(delivery.id, 'sent');
+    return { request, delivery };
+  }
+
+  // ── getPendingDeliveriesByConversation ──────────────────────────────
+
+  test('getPendingDeliveriesByConversation returns all pending deliveries for a conversation', () => {
+    const sharedConvId = 'shared-pending-conv';
+    ensureConversation(sharedConvId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-p1', sharedConvId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-p2', sharedConvId);
+
+    const deliveries = getPendingDeliveriesByConversation(sharedConvId);
+    expect(deliveries).toHaveLength(2);
+
+    const requestIds = deliveries.map((d) => d.requestId);
+    expect(requestIds).toContain(req1.id);
+    expect(requestIds).toContain(req2.id);
+  });
+
+  test('getPendingDeliveriesByConversation returns single delivery (fast path preserved)', () => {
+    const convId = 'single-pending-conv';
+    ensureConversation(convId);
+
+    const { request } = createPendingRequestWithDelivery('source-conv-single-p', convId);
+
+    const deliveries = getPendingDeliveriesByConversation(convId);
+    expect(deliveries).toHaveLength(1);
+    expect(deliveries[0].requestId).toBe(request.id);
+  });
+
+  test('getPendingDeliveryByConversation returns first from multiple (backward compat)', () => {
+    const convId = 'compat-pending-conv';
+    ensureConversation(convId);
+
+    createPendingRequestWithDelivery('source-conv-compat-p1', convId);
+    createPendingRequestWithDelivery('source-conv-compat-p2', convId);
+
+    const single = getPendingDeliveryByConversation(convId);
+    expect(single).not.toBeNull();
+  });
+
+  test('getPendingDeliveriesByConversation returns empty for non-matching conversation', () => {
+    ensureConversation('other-conv');
+    createPendingRequestWithDelivery('source-conv-no-match', 'other-conv');
+
+    const deliveries = getPendingDeliveriesByConversation('nonexistent-conv');
+    expect(deliveries).toHaveLength(0);
+  });
+
+  // ── getExpiredDeliveriesByConversation ──────────────────────────────
+
+  test('getExpiredDeliveriesByConversation returns all expired deliveries for a conversation', () => {
+    const sharedConvId = 'shared-expired-conv';
+    ensureConversation(sharedConvId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-e1', sharedConvId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-e2', sharedConvId);
+
+    expireGuardianActionRequest(req1.id, 'sweep_timeout');
+    expireGuardianActionRequest(req2.id, 'sweep_timeout');
+
+    const deliveries = getExpiredDeliveriesByConversation(sharedConvId);
+    expect(deliveries).toHaveLength(2);
+
+    const requestIds = deliveries.map((d) => d.requestId);
+    expect(requestIds).toContain(req1.id);
+    expect(requestIds).toContain(req2.id);
+  });
+
+  test('getExpiredDeliveryByConversation returns first from multiple (backward compat)', () => {
+    const convId = 'compat-expired-conv';
+    ensureConversation(convId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-compat-e1', convId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-compat-e2', convId);
+
+    expireGuardianActionRequest(req1.id, 'sweep_timeout');
+    expireGuardianActionRequest(req2.id, 'sweep_timeout');
+
+    const single = getExpiredDeliveryByConversation(convId);
+    expect(single).not.toBeNull();
+  });
+
+  test('getExpiredDeliveriesByConversation excludes deliveries with followup already started', () => {
+    const convId = 'expired-with-followup-conv';
+    ensureConversation(convId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-ef1', convId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-ef2', convId);
+
+    expireGuardianActionRequest(req1.id, 'sweep_timeout');
+    expireGuardianActionRequest(req2.id, 'sweep_timeout');
+
+    // Start followup on req1 — only req2 should remain in the expired query
+    startFollowupFromExpiredRequest(req1.id, 'late answer');
+
+    const deliveries = getExpiredDeliveriesByConversation(convId);
+    expect(deliveries).toHaveLength(1);
+    expect(deliveries[0].requestId).toBe(req2.id);
+  });
+
+  // ── getFollowupDeliveriesByConversation ─────────────────────────────
+
+  test('getFollowupDeliveriesByConversation returns all awaiting_guardian_choice deliveries', () => {
+    const convId = 'shared-followup-conv';
+    ensureConversation(convId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-f1', convId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-f2', convId);
+
+    expireGuardianActionRequest(req1.id, 'sweep_timeout');
+    expireGuardianActionRequest(req2.id, 'sweep_timeout');
+
+    startFollowupFromExpiredRequest(req1.id, 'late answer 1');
+    startFollowupFromExpiredRequest(req2.id, 'late answer 2');
+
+    const deliveries = getFollowupDeliveriesByConversation(convId);
+    expect(deliveries).toHaveLength(2);
+
+    const requestIds = deliveries.map((d) => d.requestId);
+    expect(requestIds).toContain(req1.id);
+    expect(requestIds).toContain(req2.id);
+  });
+
+  test('getFollowupDeliveryByConversation returns first from multiple (backward compat)', () => {
+    const convId = 'compat-followup-conv';
+    ensureConversation(convId);
+
+    const { request: req1 } = createPendingRequestWithDelivery('source-conv-compat-f1', convId);
+    const { request: req2 } = createPendingRequestWithDelivery('source-conv-compat-f2', convId);
+
+    expireGuardianActionRequest(req1.id, 'sweep_timeout');
+    expireGuardianActionRequest(req2.id, 'sweep_timeout');
+
+    startFollowupFromExpiredRequest(req1.id, 'late 1');
+    startFollowupFromExpiredRequest(req2.id, 'late 2');
+
+    const single = getFollowupDeliveryByConversation(convId);
+    expect(single).not.toBeNull();
+  });
+
+  test('getFollowupDeliveriesByConversation returns empty for non-matching conversation', () => {
+    const deliveries = getFollowupDeliveriesByConversation('nonexistent-conv');
+    expect(deliveries).toHaveLength(0);
+  });
+
+  // ── cancelGuardianActionRequest ─────────────────────────────────────
+
   test('cancelGuardianActionRequest cancels both pending and sent deliveries', () => {
     const conversationId = 'conv-guardian-cancel';
     ensureConversation(conversationId);

package/src/__tests__/guardian-dispatch.test.ts

@@ -335,4 +335,184 @@ describe('guardian-dispatch', () => {
     expect(vellumDelivery).toBeDefined();
     expect(vellumDelivery!.destination_conversation_id).toBe('conv-from-thread-created');
   });
+
+  test('persists toolName and inputDigest on guardian action request for tool-approval dispatches', async () => {
+    const convId = 'conv-dispatch-5';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'Allow send_email to bob@example.com?');
+
+    await dispatchGuardianQuestion({
+      callSessionId: session.id,
+      conversationId: convId,
+      assistantId: 'self',
+      pendingQuestion: pq,
+      toolName: 'send_email',
+      inputDigest: 'abc123def456',
+    });
+
+    const db = getDb();
+    const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
+    const request = raw.query('SELECT * FROM guardian_action_requests WHERE call_session_id = ?').get(session.id) as
+      | { id: string; tool_name: string | null; input_digest: string | null }
+      | undefined;
+    expect(request).toBeDefined();
+    expect(request!.tool_name).toBe('send_email');
+    expect(request!.input_digest).toBe('abc123def456');
+  });
+
+  test('omitting toolName and inputDigest stores null for informational ASK_GUARDIAN dispatches', async () => {
+    const convId = 'conv-dispatch-6';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'What time works?');
+
+    await dispatchGuardianQuestion({
+      callSessionId: session.id,
+      conversationId: convId,
+      assistantId: 'self',
+      pendingQuestion: pq,
+    });
+
+    const db = getDb();
+    const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
+    const request = raw.query('SELECT * FROM guardian_action_requests WHERE call_session_id = ?').get(session.id) as
+      | { id: string; tool_name: string | null; input_digest: string | null }
+      | undefined;
+    expect(request).toBeDefined();
+    expect(request!.tool_name).toBeNull();
+    expect(request!.input_digest).toBeNull();
+  });
+
+  test('includes activeGuardianRequestCount in context payload', async () => {
+    const convId = 'conv-dispatch-7';
+    ensureConversation(convId);
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+    const pq = createPendingQuestion(session.id, 'First question');
+
+    await dispatchGuardianQuestion({
+      callSessionId: session.id,
+      conversationId: convId,
+      assistantId: 'self',
+      pendingQuestion: pq,
+    });
+
+    const signalParams = emitCalls[0] as Record<string, unknown>;
+    const payload = signalParams.contextPayload as Record<string, unknown>;
+    // The request was just created so there is 1 pending request for this session
+    expect(payload.activeGuardianRequestCount).toBe(1);
+    expect(payload.callSessionId).toBe(session.id);
+  });
+
+  test('repeated guardian questions in the same call each create per-request delivery rows even when sharing a conversation', async () => {
+    const convId = 'conv-dispatch-reuse-1';
+    ensureConversation(convId);
+
+    // Both dispatches deliver to the same vellum conversation (simulating thread reuse)
+    const sharedConversationId = 'conv-shared-guardian';
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    // First dispatch
+    const pq1 = createPendingQuestion(session.id, 'What is the gate code?');
+    mockEmitResult = {
+      signalId: 'sig-reuse-1',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [
+        {
+          channel: 'vellum',
+          destination: 'vellum',
+          status: 'sent',
+          conversationId: sharedConversationId,
+        },
+      ],
+    };
+
+    await dispatchGuardianQuestion({
+      callSessionId: session.id,
+      conversationId: convId,
+      assistantId: 'self',
+      pendingQuestion: pq1,
+    });
+
+    // Second dispatch (same call session, same shared conversation)
+    emitCalls.length = 0;
+    const pq2 = createPendingQuestion(session.id, 'Should I let them in?');
+    mockEmitResult = {
+      signalId: 'sig-reuse-2',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [
+        {
+          channel: 'vellum',
+          destination: 'vellum',
+          status: 'sent',
+          conversationId: sharedConversationId,
+        },
+      ],
+    };
+
+    await dispatchGuardianQuestion({
+      callSessionId: session.id,
+      conversationId: convId,
+      assistantId: 'self',
+      pendingQuestion: pq2,
+    });
+
+    // Both dispatches should have created separate action requests
+    const db = getDb();
+    const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
+    const requests = raw.query(
+      'SELECT * FROM guardian_action_requests WHERE call_session_id = ? ORDER BY created_at ASC',
+    ).all(session.id) as Array<{ id: string; question_text: string }>;
+    expect(requests).toHaveLength(2);
+    expect(requests[0].question_text).toBe('What is the gate code?');
+    expect(requests[1].question_text).toBe('Should I let them in?');
+
+    // Each request should have its own delivery row, both pointing to the shared conversation
+    for (const req of requests) {
+      const delivery = raw.query(
+        'SELECT * FROM guardian_action_deliveries WHERE request_id = ? AND destination_channel = ?',
+      ).get(req.id, 'vellum') as { status: string; destination_conversation_id: string | null } | undefined;
+      expect(delivery).toBeDefined();
+      expect(delivery!.status).toBe('sent');
+      expect(delivery!.destination_conversation_id).toBe(sharedConversationId);
+    }
+
+    // Total delivery rows should be 2 (one per request), not 1
+    const allDeliveries = raw.query(
+      'SELECT * FROM guardian_action_deliveries WHERE destination_conversation_id = ?',
+    ).all(sharedConversationId) as Array<{ request_id: string }>;
+    expect(allDeliveries).toHaveLength(2);
+
+    // Second dispatch should report a higher activeGuardianRequestCount
+    const secondPayload = (emitCalls[0] as Record<string, unknown>).contextPayload as Record<string, unknown>;
+    expect(secondPayload.activeGuardianRequestCount).toBe(2);
+  });
 });