@vellumai/assistant 0.4.3 → 0.4.4

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -100,6 +100,9 @@ interface TestSession {
   setAssistantId: (assistantId: string) => void;
   setGuardianContext: (ctx: unknown) => void;
   setCommandIntent: (intent: unknown) => void;
+  updateClient: (sendToClient: (msg: ServerMessage) => void, hasNoClient?: boolean) => void;
+  emitActivityState: (...args: unknown[]) => void;
+  emitConfirmationStateChanged: (...args: unknown[]) => void;
   processMessage: (...args: unknown[]) => Promise<string>;
 }
 
@@ -153,6 +156,9 @@ function makeSession(overrides: Partial<TestSession> = {}): TestSession {
     setAssistantId: () => {},
     setGuardianContext: () => {},
     setCommandIntent: () => {},
+    updateClient: () => {},
+    emitActivityState: () => {},
+    emitConfirmationStateChanged: () => {},
     processMessage: async () => 'msg-id',
     ...overrides,
   };
@@ -411,6 +417,53 @@ describe('handleUserMessage pending-confirmation reply interception', () => {
     expect(sent.some((event) => event.type === 'confirmation_request')).toBe(true);
   });
 
+  test('registers IPC confirmation events emitted via session sender (prompter path)', async () => {
+    let currentSender: (msg: ServerMessage) => void = () => {};
+    const session = makeSession({
+      hasAnyPendingConfirmation: () => false,
+      enqueueMessage: mock(() => ({ queued: false, requestId: 'direct-id' })),
+      updateClient: (sendToClient: (msg: ServerMessage) => void) => {
+        currentSender = sendToClient;
+      },
+      processMessage: async () => {
+        currentSender({
+          type: 'confirmation_request',
+          requestId: 'req-prompter-1',
+          toolName: 'call_start',
+          input: { phone_number: '+18084436762' },
+          riskLevel: 'high',
+          executionTarget: 'host',
+          allowlistOptions: [],
+          scopeOptions: [],
+          persistentDecisionsAllowed: false,
+        } as ServerMessage);
+        return 'msg-id';
+      },
+    });
+    const { ctx, sent } = createContext(session);
+
+    await handleUserMessage(makeMessage('please call now'), {} as net.Socket, ctx);
+
+    expect(registerMock).toHaveBeenCalledWith(
+      'req-prompter-1',
+      expect.objectContaining({
+        conversationId: 'conv-1',
+        kind: 'confirmation',
+        session,
+      }),
+    );
+    expect(createCanonicalGuardianRequestMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'req-prompter-1',
+        kind: 'tool_approval',
+        sourceType: 'desktop',
+        sourceChannel: 'vellum',
+        conversationId: 'conv-1',
+      }),
+    );
+    expect(sent.some((event) => event.type === 'confirmation_request')).toBe(true);
+  });
+
   test('syncs canonical status to approved for IPC allow decisions', () => {
     const session = {
       hasPendingConfirmation: (requestId: string) => requestId === 'req-confirm-allow',
@@ -433,6 +486,8 @@ describe('handleUserMessage pending-confirmation reply interception', () => {
       'always_allow',
       undefined,
       undefined,
+      undefined,
+      { source: 'button' },
     ]);
     expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
       'req-confirm-allow',

package/src/__tests__/headless-browser-navigate.test.ts

@@ -32,6 +32,8 @@ mock.module('../tools/browser/browser-manager.js', () => {
       getOrCreateSessionPage: getOrCreateSessionPageMock,
       clearSnapshotMap: mock(() => {}),
       supportsRouteInterception: true,
+      isInteractive: () => false,
+      positionWindowSidebar: () => {},
     },
   };
 });

package/src/__tests__/ipc-snapshot.test.ts

@@ -422,16 +422,6 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'telegram_config',
     action: 'get',
   },
-  twilio_config: {
-    type: 'twilio_config',
-    action: 'get',
-  },
-  channel_readiness: {
-    type: 'channel_readiness',
-    action: 'get',
-    channel: 'sms',
-    includeRemote: true,
-  },
   guardian_verification: {
     type: 'guardian_verification',
     action: 'create_challenge',
@@ -823,6 +813,24 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     sandboxed: false,
     sessionId: 'sess-001',
   },
+  confirmation_state_changed: {
+    type: 'confirmation_state_changed',
+    sessionId: 'sess-001',
+    requestId: 'req-002',
+    state: 'approved',
+    source: 'inline_nl',
+    causedByRequestId: 'req-003',
+    decisionText: 'approve',
+  },
+  assistant_activity_state: {
+    type: 'assistant_activity_state',
+    sessionId: 'sess-001',
+    activityVersion: 1,
+    phase: 'thinking',
+    anchor: 'assistant_turn',
+    requestId: 'req-003',
+    reason: 'message_dequeued',
+  },
   message_complete: {
     type: 'message_complete',
     sessionId: 'sess-001',
@@ -1446,47 +1454,6 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
     connected: true,
     hasWebhookSecret: true,
   },
-  twilio_config_response: {
-    type: 'twilio_config_response',
-    success: true,
-    hasCredentials: true,
-    phoneNumber: '+15551234567',
-    compliance: {
-      numberType: 'toll_free',
-      verificationSid: 'TF_VER_001',
-      verificationStatus: 'TWILIO_APPROVED',
-    },
-    testResult: {
-      messageSid: 'SM-test-001',
-      to: '+15559876543',
-      initialStatus: 'queued',
-      finalStatus: 'delivered',
-    },
-    diagnostics: {
-      readiness: { ready: true, issues: [] },
-      compliance: { status: 'TWILIO_APPROVED', detail: 'Toll-free verification: TWILIO_APPROVED' },
-      overallStatus: 'healthy',
-      actionItems: [],
-    },
-  },
-  channel_readiness_response: {
-    type: 'channel_readiness_response',
-    success: true,
-    snapshots: [
-      {
-        channel: 'sms',
-        ready: false,
-        checkedAt: 1700000000000,
-        stale: false,
-        reasons: [{ code: 'twilio_credentials', text: 'Twilio credentials are not configured' }],
-        localChecks: [
-          { name: 'twilio_credentials', passed: false, message: 'Twilio credentials are not configured' },
-          { name: 'phone_number', passed: true, message: 'Phone number is assigned' },
-          { name: 'ingress', passed: true, message: 'Public ingress URL is configured' },
-        ],
-      },
-    ],
-  },
   guardian_verification_response: {
     type: 'guardian_verification_response',
     success: true,

package/src/__tests__/non-member-access-request.test.ts

@@ -58,16 +58,23 @@ mock.module('../config/env.js', () => ({
 
 // Track emitNotificationSignal calls
 const emitSignalCalls: Array<Record<string, unknown>> = [];
+let mockEmitResult: {
+  signalId: string;
+  deduplicated: boolean;
+  dispatched: boolean;
+  reason: string;
+  deliveryResults: Array<Record<string, unknown>>;
+} = {
+  signalId: 'mock-signal-id',
+  deduplicated: false,
+  dispatched: true,
+  reason: 'mock',
+  deliveryResults: [],
+};
 mock.module('../notifications/emit-signal.js', () => ({
   emitNotificationSignal: async (params: Record<string, unknown>) => {
     emitSignalCalls.push(params);
-    return {
-      signalId: 'mock-signal-id',
-      deduplicated: false,
-      dispatched: true,
-      reason: 'mock',
-      deliveryResults: [],
-    };
+    return mockEmitResult;
   },
 }));
 
@@ -79,7 +86,10 @@ mock.module('../runtime/gateway-client.js', () => ({
   },
 }));
 
-import { listCanonicalGuardianRequests } from '../memory/canonical-guardian-store.js';
+import {
+  listCanonicalGuardianDeliveries,
+  listCanonicalGuardianRequests,
+} from '../memory/canonical-guardian-store.js';
 import {
   createBinding,
 } from '../memory/channel-guardian-store.js';
@@ -111,6 +121,17 @@ function resetState(): void {
   db.run('DELETE FROM canonical_guardian_deliveries');
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
+  mockEmitResult = {
+    signalId: 'mock-signal-id',
+    deduplicated: false,
+    dispatched: true,
+    reason: 'mock',
+    deliveryResults: [],
+  };
+}
+
+async function flushAsyncAccessRequestBookkeeping(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 function buildInboundRequest(overrides: Record<string, unknown> = {}): Request {
@@ -481,4 +502,106 @@ describe('access-request-helper unit tests', () => {
     expect(typeof payload.requestCode).toBe('string');
     expect((payload.requestCode as string).length).toBe(6);
   });
+
+  test('notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload', () => {
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'revoked-user',
+      senderName: 'Revoked User',
+      previousMemberStatus: 'revoked',
+    });
+
+    expect(result.notified).toBe(true);
+    expect(emitSignalCalls.length).toBe(1);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
+    expect(payload.previousMemberStatus).toBe('revoked');
+  });
+
+  test('notifyGuardianOfAccessRequest persists canonical delivery rows from notification results', async () => {
+    mockEmitResult = {
+      signalId: 'sig-deliveries',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [
+        {
+          channel: 'vellum',
+          destination: 'vellum',
+          status: 'sent',
+          conversationId: 'conv-guardian-access-request',
+        },
+        {
+          channel: 'telegram',
+          destination: 'guardian-chat-123',
+          status: 'sent',
+        },
+      ],
+    };
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'voice',
+      externalChatId: '+15556667777',
+      senderExternalUserId: '+15556667777',
+      senderName: 'Noah',
+    });
+
+    expect(result.notified).toBe(true);
+    if (!result.notified) return;
+
+    await flushAsyncAccessRequestBookkeeping();
+
+    const deliveries = listCanonicalGuardianDeliveries(result.requestId);
+    const vellum = deliveries.find((d) => d.destinationChannel === 'vellum');
+    const telegram = deliveries.find((d) => d.destinationChannel === 'telegram');
+
+    expect(vellum).toBeDefined();
+    expect(vellum!.destinationConversationId).toBe('conv-guardian-access-request');
+    expect(vellum!.status).toBe('sent');
+    expect(telegram).toBeDefined();
+    expect(telegram!.destinationChatId).toBe('guardian-chat-123');
+    expect(telegram!.status).toBe('sent');
+  });
+
+  test('notifyGuardianOfAccessRequest records failed vellum fallback when pipeline has no vellum delivery', async () => {
+    mockEmitResult = {
+      signalId: 'sig-no-vellum',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'telegram-only',
+      deliveryResults: [
+        {
+          channel: 'telegram',
+          destination: 'guardian-chat-456',
+          status: 'sent',
+        },
+      ],
+    };
+
+    const result = notifyGuardianOfAccessRequest({
+      canonicalAssistantId: 'self',
+      sourceChannel: 'telegram',
+      externalChatId: 'chat-123',
+      senderExternalUserId: 'unknown-user',
+      senderName: 'Alice',
+    });
+
+    expect(result.notified).toBe(true);
+    if (!result.notified) return;
+
+    await flushAsyncAccessRequestBookkeeping();
+
+    const deliveries = listCanonicalGuardianDeliveries(result.requestId);
+    const vellum = deliveries.find((d) => d.destinationChannel === 'vellum');
+    const telegram = deliveries.find((d) => d.destinationChannel === 'telegram');
+
+    expect(vellum).toBeDefined();
+    expect(vellum!.status).toBe('failed');
+    expect(telegram).toBeDefined();
+    expect(telegram!.destinationChatId).toBe('guardian-chat-456');
+    expect(telegram!.status).toBe('sent');
+  });
 });

package/src/__tests__/notification-decision-fallback.test.ts

@@ -96,22 +96,27 @@ describe('notification decision fallback copy', () => {
     expect(decision.renderedCopy.vellum?.body).not.toContain('Action required: guardian.question');
   });
 
-  test('enforces request-code instructions for guardian.question when requestCode exists', async () => {
+  test('enforces free-text answer instructions for guardian.question when requestCode exists', async () => {
     const signal = makeSignal({
       contextPayload: {
+        requestId: 'req-pending-1',
         questionText: 'What is the gate code?',
         requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
       },
     });
     const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
 
     expect(decision.fallbackUsed).toBe(true);
     expect(decision.renderedCopy.vellum?.body).toContain('A1B2C3');
-    expect(decision.renderedCopy.vellum?.body).toContain('approve');
-    expect(decision.renderedCopy.vellum?.body).toContain('reject');
+    expect(decision.renderedCopy.vellum?.body).toContain('<your answer>');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('approve');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('reject');
   });
 
-  test('enforcement appends explicit approve/reject instructions when LLM copy only mentions request code', async () => {
+  test('enforcement appends free-text answer instructions when LLM copy only mentions request code', async () => {
     configuredProvider = {
       sendMessage: async () => ({ content: [] }),
     };
@@ -134,8 +139,127 @@ describe('notification decision fallback copy', () => {
 
     const signal = makeSignal({
       contextPayload: {
+        requestId: 'req-pending-1',
         questionText: 'What is the gate code?',
         requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 <your answer>"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('"A1B2C3 reject"');
+  });
+
+  test('enforcement appends answer instructions when LLM copy incorrectly uses approve/reject wording', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+          },
+        },
+        dedupeKey: 'guardian-question-wrong-instructions-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-pending-approve-phrasing',
+        questionText: 'What is the gate code?',
+        requestCode: 'A1B2C3',
+        requestKind: 'pending_question',
+        callSessionId: 'call-1',
+        activeGuardianRequestCount: 1,
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 <your answer>"');
+  });
+
+  test('enforcement appends explicit approve/reject instructions for tool-approval guardian questions', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Use reference code A1B2C3 for this request.',
+          },
+        },
+        dedupeKey: 'guardian-question-tool-approval-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-grant-1',
+        questionText: 'Allow running host_bash?',
+        requestCode: 'A1B2C3',
+        requestKind: 'tool_grant_request',
+        toolName: 'host_bash',
+      },
+    });
+
+    const decision = await evaluateSignal(signal, ['vellum'] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
+  });
+
+  test('approval-mode enforcement removes conflicting answer-mode phrasing', async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: 'record_notification_decision',
+      input: {
+        shouldNotify: true,
+        selectedChannels: ['vellum'],
+        reasoningSummary: 'LLM decision',
+        renderedCopy: {
+          vellum: {
+            title: 'Guardian Question',
+            body: 'Reference code: A1B2C3. Reply "A1B2C3 <your answer>".',
+          },
+        },
+        dedupeKey: 'guardian-question-approval-removes-answer-test',
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: 'req-grant-2',
+        questionText: 'Allow running host_bash?',
+        requestCode: 'A1B2C3',
+        requestKind: 'tool_grant_request',
+        toolName: 'host_bash',
       },
     });
 
@@ -144,5 +268,6 @@ describe('notification decision fallback copy', () => {
     expect(decision.fallbackUsed).toBe(false);
     expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
     expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
+    expect(decision.renderedCopy.vellum?.body).not.toContain('<your answer>');
   });
 });

package/src/__tests__/notification-decision-strategy.test.ts

@@ -55,21 +55,67 @@ describe('notification decision strategy', () => {
       expect(copy.vellum!.body).toContain('What is the gate code?');
     });
 
-    test('guardian.question template includes request-code instructions when present', () => {
+    test('guardian.question template includes free-text answer instructions when requestCode is present', () => {
       const signal = makeSignal({
         sourceEventName: 'guardian.question',
         contextPayload: {
+          requestId: 'req-pending-1',
           questionText: 'What is the gate code?',
           requestCode: 'A1B2C3',
+          requestKind: 'pending_question',
+          callSessionId: 'call-1',
+          activeGuardianRequestCount: 1,
         },
       });
 
       const copy = composeFallbackCopy(signal, channels);
       expect(copy.vellum).toBeDefined();
       expect(copy.vellum!.body).toContain('A1B2C3');
+      expect(copy.vellum!.body).toContain('<your answer>');
+      expect(copy.vellum!.body).not.toContain('approve');
+      expect(copy.vellum!.body).not.toContain('reject');
+      expect(copy.telegram!.deliveryText).toContain('A1B2C3');
+    });
+
+    test('guardian.question template uses approve/reject instructions for approval-kind request', () => {
+      const signal = makeSignal({
+        sourceEventName: 'guardian.question',
+        contextPayload: {
+          requestId: 'req-grant-1',
+          questionText: 'Allow running host_bash?',
+          requestCode: 'D4E5F6',
+          requestKind: 'tool_grant_request',
+          toolName: 'host_bash',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('D4E5F6');
       expect(copy.vellum!.body).toContain('approve');
       expect(copy.vellum!.body).toContain('reject');
-      expect(copy.telegram!.deliveryText).toContain('A1B2C3');
+    });
+
+    test('guardian.question template uses approve/reject for tool-backed pending_question payloads', () => {
+      const signal = makeSignal({
+        sourceEventName: 'guardian.question',
+        contextPayload: {
+          requestId: 'req-voice-tool-1',
+          questionText: 'Allow send_email to bob@example.com?',
+          requestCode: 'A1B2C3',
+          requestKind: 'pending_question',
+          callSessionId: 'call-1',
+          activeGuardianRequestCount: 1,
+          toolName: 'send_email',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('A1B2C3');
+      expect(copy.vellum!.body).toContain('approve');
+      expect(copy.vellum!.body).toContain('reject');
+      expect(copy.vellum!.body).not.toContain('<your answer>');
     });
 
     test('reminder.fired template uses message from payload', () => {
@@ -196,6 +242,20 @@ describe('notification decision strategy', () => {
       expect(copy.vellum!.body).toContain('open invite flow');
     });
 
+    test('ingress.access_request template includes revoked-member context when provided', () => {
+      const signal = makeSignal({
+        sourceEventName: 'ingress.access_request',
+        contextPayload: {
+          senderIdentifier: 'Charlie',
+          previousMemberStatus: 'revoked',
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.body).toContain('previously revoked');
+    });
+
     test('ingress.access_request template includes caller name for voice-originated requests', () => {
       // In production, senderIdentifier resolves to senderName for voice
       // calls (senderName || senderUsername || senderExternalUserId), so

package/src/__tests__/notification-guardian-path.test.ts

@@ -181,6 +181,9 @@ describe('ASK_GUARDIAN canonical notification path', () => {
     const payload = signalParams.contextPayload as Record<string, unknown>;
     expect(payload.questionText).toBe('What is the gate code?');
     expect(payload.callSessionId).toBe(session.id);
+    expect(payload.requestKind).toBe('pending_question');
+    expect(payload.toolName).toBeUndefined();
+    expect(payload.pendingQuestionId).toBeUndefined();
     expect(payload.requestId).toBeDefined();
     expect(payload.requestCode).toBeDefined();
   });

package/src/__tests__/recording-intent-handler.test.ts

@@ -391,6 +391,7 @@ function createCtx(overrides?: Partial<HandlerContext>): {
     setChannelCapabilities: noop,
     setGuardianContext: noop,
     setCommandIntent: noop,
+    updateClient: noop,
     processMessage: async () => {},
     getQueueDepth: () => 0,
     setPreactivatedSkillIds: noop,