@vellumai/assistant 0.3.18 → 0.3.20

package/src/__tests__/guardian-control-plane-policy.test.ts

@@ -484,15 +484,15 @@ describe('ToolExecutor guardian-only policy gate', () => {
     expect(result.content).toBe('ok');
   });
 
-  test('non-guardian invocation of unrelated endpoint is unaffected', async () => {
+  test('non-guardian invocation of unrelated bash command is blocked by guardian approval gate', async () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       'bash',
       { command: 'curl http://localhost:3000/v1/messages' },
       makeContext({ guardianActorRole: 'non-guardian' }),
     );
-    expect(result.isError).toBe(false);
-    expect(result.content).toBe('ok');
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('requires guardian approval');
   });
 
   test('non-guardian invocation of unrelated tool is unaffected', async () => {
@@ -579,4 +579,37 @@ describe('ToolExecutor guardian-only policy gate', () => {
       expect(result.content).toContain('restricted to guardian users');
     }
   });
+
+  test('non-guardian actor is blocked from host read tools (host execution)', async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      'host_file_read',
+      { path: '/Users/noaflaherty/.ssh/config' },
+      makeContext({ guardianActorRole: 'non-guardian' }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('requires guardian approval');
+  });
+
+  test('unverified channel actor is blocked from side-effect tools', async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      'reminder_create',
+      { fire_at: '2026-02-27T12:00:00-05:00', label: 'test', message: 'hello' },
+      makeContext({ guardianActorRole: 'unverified_channel' }),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('verified channel identity');
+  });
+
+  test('guardian actor can execute side-effect tools', async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      'reminder_create',
+      { fire_at: '2026-02-27T12:00:00-05:00', label: 'test', message: 'hello' },
+      makeContext({ guardianActorRole: 'guardian' }),
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe('ok');
+  });
 });

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

@@ -336,10 +336,70 @@ describe('guardian-dispatch', () => {
     expect(vellumDelivery!.destination_conversation_id).toBe('conv-from-thread-created');
   });
 
-  test('includes activeGuardianRequestCount in context payload', async () => {
+  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',
@@ -455,4 +515,128 @@ describe('guardian-dispatch', () => {
     const secondPayload = (emitCalls[0] as Record<string, unknown>).contextPayload as Record<string, unknown>;
     expect(secondPayload.activeGuardianRequestCount).toBe(2);
   });
+
+  test('second guardian question in same call session passes conversationAffinityHint with first conversation ID', async () => {
+    const convId = 'conv-dispatch-affinity-1';
+    ensureConversation(convId);
+
+    const sharedConversationId = 'conv-affinity-guardian';
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    // First dispatch — no affinity hint expected (no prior delivery exists)
+    const pq1 = createPendingQuestion(session.id, 'First question');
+    mockEmitResult = {
+      signalId: 'sig-affinity-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,
+    });
+
+    const firstParams = emitCalls[0] as Record<string, unknown>;
+    // First dispatch should not have an affinity hint
+    expect(firstParams.conversationAffinityHint).toBeUndefined();
+
+    // Second dispatch — should carry the affinity hint from the first delivery
+    emitCalls.length = 0;
+    const pq2 = createPendingQuestion(session.id, 'Second question');
+    mockEmitResult = {
+      signalId: 'sig-affinity-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,
+    });
+
+    const secondParams = emitCalls[0] as Record<string, unknown>;
+    expect(secondParams.conversationAffinityHint).toEqual({
+      vellum: sharedConversationId,
+    });
+  });
+
+  test('third guardian question in same call session also carries affinity hint', async () => {
+    const convId = 'conv-dispatch-affinity-2';
+    ensureConversation(convId);
+
+    const sharedConversationId = 'conv-affinity-triple';
+
+    const session = createCallSession({
+      conversationId: convId,
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15550002222',
+    });
+
+    // Dispatch three guardian questions in the same call session
+    for (let i = 0; i < 3; i++) {
+      emitCalls.length = 0;
+      const pq = createPendingQuestion(session.id, `Question ${i + 1}`);
+      mockEmitResult = {
+        signalId: `sig-triple-${i}`,
+        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: pq,
+      });
+
+      const params = emitCalls[0] as Record<string, unknown>;
+      if (i === 0) {
+        // First dispatch — no affinity hint
+        expect(params.conversationAffinityHint).toBeUndefined();
+      } else {
+        // Subsequent dispatches — affinity hint points to the shared conversation
+        expect(params.conversationAffinityHint).toEqual({
+          vellum: sharedConversationId,
+        });
+      }
+    }
+  });
 });