@vellumai/assistant 0.4.2 → 0.4.4

package/src/__tests__/channel-readiness-service.test.ts

@@ -302,24 +302,18 @@ describe('ChannelReadinessService', () => {
     expect(snapshot.reasons).toEqual([]);
   });
 
-  test('remote cache is scoped per assistantId', async () => {
-    const remoteCalls: Record<string, number> = {};
-    const probe: ChannelProbe = {
-      channel: 'sms',
-      runLocalChecks: () => [{ name: 'local', passed: true, message: 'ok' }],
-      async runRemoteChecks(context) {
-        const key = context?.assistantId ?? '__default__';
-        remoteCalls[key] = (remoteCalls[key] ?? 0) + 1;
-        return [{ name: 'remote', passed: true, message: `ok-${key}` }];
-      },
-    };
+  test('remote cache uses fixed internal scope (no per-assistantId scoping)', async () => {
+    const probe = makeProbe(
+      'sms',
+      [{ name: 'local', passed: true, message: 'ok' }],
+      [{ name: 'remote', passed: true, message: 'ok' }],
+    );
     service.registerProbe(probe);
 
-    await service.getReadiness('sms', true, 'ast-alpha');
-    await service.getReadiness('sms', true, 'ast-beta');
-    await service.getReadiness('sms', true, 'ast-alpha');
+    // All calls share the same cache key since there is no assistantId dimension
+    await service.getReadiness('sms', true);
+    await service.getReadiness('sms', true);
 
-    expect(remoteCalls['ast-alpha']).toBe(1);
-    expect(remoteCalls['ast-beta']).toBe(1);
+    expect(probe.remoteCallCount).toBe(1);
   });
 });

package/src/__tests__/checker.test.ts

@@ -63,7 +63,7 @@ mock.module('../config/loader.js', () => ({
   setNestedValue: () => {},
 }));
 
-import { _resetLegacyDeprecationWarning,check, classifyRisk, generateAllowlistOptions, generateScopeOptions } from '../permissions/checker.js';
+import { _resetLegacyDeprecationWarning,check, classifyRisk, generateAllowlistOptions, generateScopeOptions, SCOPE_AWARE_TOOLS } from '../permissions/checker.js';
 import { getDefaultRuleTemplates } from '../permissions/defaults.js';
 import { addRule, clearCache, findHighestPriorityRule } from '../permissions/trust-store.js';
 import type { TrustRule } from '../permissions/types.js';
@@ -1341,21 +1341,42 @@ describe('Permission Checker', () => {
       expect(options[2]).toEqual({ label: 'everywhere', scope: 'everywhere' });
     });
 
-    test('scope options are always project → parent → everywhere regardless of tool', () => {
+    test('scope-aware tools all produce the same directory-based ordering', () => {
       const workingDir = join(homedir(), 'projects', 'myapp');
 
-      // Non-host tool
-      const nonHostOpts = generateScopeOptions(workingDir, 'bash');
-      expect(nonHostOpts[0].scope).toBe(workingDir);
-      expect(nonHostOpts[nonHostOpts.length - 1].scope).toBe('everywhere');
+      const bashOpts = generateScopeOptions(workingDir, 'bash');
+      expect(bashOpts[0].scope).toBe(workingDir);
+      expect(bashOpts[bashOpts.length - 1].scope).toBe('everywhere');
 
-      // Host tool — same order now
-      const hostOpts = generateScopeOptions(workingDir, 'host_bash');
-      expect(hostOpts[0].scope).toBe(workingDir);
-      expect(hostOpts[hostOpts.length - 1].scope).toBe('everywhere');
+      const hostBashOpts = generateScopeOptions(workingDir, 'host_bash');
+      expect(bashOpts.map(o => o.scope)).toEqual(hostBashOpts.map(o => o.scope));
 
-      // Same ordering for both
-      expect(nonHostOpts.map(o => o.scope)).toEqual(hostOpts.map(o => o.scope));
+      const fileOpts = generateScopeOptions(workingDir, 'file_write');
+      expect(bashOpts.map(o => o.scope)).toEqual(fileOpts.map(o => o.scope));
+    });
+
+    test('returns empty for non-scoped tools', () => {
+      const workingDir = join(homedir(), 'projects', 'myapp');
+      expect(generateScopeOptions(workingDir, 'web_fetch')).toHaveLength(0);
+      expect(generateScopeOptions(workingDir, 'browser_navigate')).toHaveLength(0);
+      expect(generateScopeOptions(workingDir, 'skill_load')).toHaveLength(0);
+      expect(generateScopeOptions(workingDir, 'credential_store')).toHaveLength(0);
+      expect(generateScopeOptions(workingDir, 'computer_use_click')).toHaveLength(0);
+      expect(generateScopeOptions(workingDir, 'my_custom_mcp_tool')).toHaveLength(0);
+    });
+
+    test('returns directory options when toolName is omitted (backward compat)', () => {
+      const options = generateScopeOptions('/home/user/project');
+      expect(options).toHaveLength(3);
+      expect(options[0].scope).toBe('/home/user/project');
+    });
+
+    test('SCOPE_AWARE_TOOLS contains only filesystem and shell tools', () => {
+      expect(SCOPE_AWARE_TOOLS).toEqual(new Set([
+        'bash', 'host_bash',
+        'file_read', 'file_write', 'file_edit',
+        'host_file_read', 'host_file_write', 'host_file_edit',
+      ]));
     });
   });
 

package/src/__tests__/config-schema.test.ts

@@ -581,6 +581,12 @@ describe('AssistantConfigSchema', () => {
       provider: 'twilio',
       maxDurationSeconds: 3600,
       userConsultTimeoutSeconds: 120,
+      ttsPlaybackDelayMs: 3000,
+      accessRequestPollIntervalMs: 500,
+      guardianWaitUpdateInitialIntervalMs: 5000,
+      guardianWaitUpdateInitialWindowMs: 30000,
+      guardianWaitUpdateSteadyMinIntervalMs: 7000,
+      guardianWaitUpdateSteadyMaxIntervalMs: 10000,
       disclosure: {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -0,0 +1,410 @@
+/**
+ * Tests for the confirmation-request -> guardian.question notification bridge.
+ *
+ * Verifies that:
+ * 1. Trusted-contact confirmation_requests emit guardian.question notifications
+ * 2. Canonical delivery rows are persisted for guardian destinations
+ * 3. Guardian and unknown actor sessions are correctly skipped
+ * 4. Missing guardian binding causes a skip
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const testDir = mkdtempSync(join(tmpdir(), 'confirmation-bridge-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: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  isDebug: () => false,
+  truncateForLog: (value: string) => value,
+}));
+
+// Mock notification emission — capture calls without running the full pipeline
+const emittedSignals: Array<Record<string, unknown>> = [];
+const mockOnThreadCreatedCallbacks: Array<(info: { conversationId: string; title: string; sourceEventName: string }) => void> = [];
+mock.module('../notifications/emit-signal.js', () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emittedSignals.push(params);
+    // Capture onThreadCreated callback so tests can invoke it
+    if (typeof params.onThreadCreated === 'function') {
+      mockOnThreadCreatedCallbacks.push(params.onThreadCreated as (info: { conversationId: string; title: string; sourceEventName: string }) => void);
+    }
+    return {
+      signalId: 'test-signal',
+      deduplicated: false,
+      dispatched: true,
+      reason: 'ok',
+      deliveryResults: [
+        { channel: 'telegram', destination: 'guardian-chat-1', success: true },
+      ],
+    };
+  },
+  registerBroadcastFn: () => {},
+}));
+
+// Mock channel guardian service — provide a guardian binding for 'self' + 'telegram'
+mock.module('../runtime/channel-guardian-service.js', () => ({
+  getGuardianBinding: (assistantId: string, channel: string) => {
+    if (assistantId === 'self' && channel === 'telegram') {
+      return {
+        id: 'binding-1',
+        assistantId: 'self',
+        channel: 'telegram',
+        guardianExternalUserId: 'guardian-1',
+        guardianDeliveryChatId: 'guardian-chat-1',
+        status: 'active',
+      };
+    }
+    return null;
+  },
+}));
+
+import type { GuardianRuntimeContext } from '../daemon/session-runtime-assembly.js';
+import {
+  createCanonicalGuardianRequest,
+  generateCanonicalRequestCode,
+  listCanonicalGuardianDeliveries,
+} from '../memory/canonical-guardian-store.js';
+import { getDb, initializeDb, resetDb } from '../memory/db.js';
+import { bridgeConfirmationRequestToGuardian } from '../runtime/confirmation-request-guardian-bridge.js';
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run('DELETE FROM canonical_guardian_deliveries');
+  db.run('DELETE FROM canonical_guardian_requests');
+}
+
+afterAll(() => {
+  resetDb();
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeCanonicalRequest(overrides: Record<string, unknown> = {}) {
+  return createCanonicalGuardianRequest({
+    id: `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    kind: 'tool_approval',
+    sourceType: 'channel',
+    sourceChannel: 'telegram',
+    conversationId: 'conv-1',
+    requesterExternalUserId: 'requester-1',
+    guardianExternalUserId: 'guardian-1',
+    toolName: 'bash',
+    status: 'pending',
+    requestCode: generateCanonicalRequestCode(),
+    expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+    ...overrides,
+  });
+}
+
+function makeTrustedContactContext(overrides: Partial<GuardianRuntimeContext> = {}): GuardianRuntimeContext {
+  return {
+    sourceChannel: 'telegram',
+    trustClass: 'trusted_contact',
+    guardianExternalUserId: 'guardian-1',
+    guardianChatId: 'guardian-chat-1',
+    requesterExternalUserId: 'requester-1',
+    requesterChatId: 'requester-chat-1',
+    requesterIdentifier: '@requester',
+    ...overrides,
+  };
+}
+
+// ===========================================================================
+// TESTS
+// ===========================================================================
+
+describe('bridgeConfirmationRequestToGuardian', () => {
+  beforeEach(() => {
+    resetTables();
+    emittedSignals.length = 0;
+    mockOnThreadCreatedCallbacks.length = 0;
+  });
+
+  test('emits guardian.question for trusted-contact sessions', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('bridged' in result && result.bridged).toBe(true);
+    expect(emittedSignals).toHaveLength(1);
+    expect(emittedSignals[0].sourceEventName).toBe('guardian.question');
+    expect(emittedSignals[0].sourceChannel).toBe('telegram');
+    expect(emittedSignals[0].sourceSessionId).toBe('conv-1');
+
+    const payload = emittedSignals[0].contextPayload as Record<string, unknown>;
+    expect(payload.requestId).toBe(canonicalRequest.id);
+    expect(payload.requestCode).toBe(canonicalRequest.requestCode);
+    expect(payload.toolName).toBe('bash');
+    expect(payload.requesterExternalUserId).toBe('requester-1');
+    expect(payload.requesterIdentifier).toBe('@requester');
+  });
+
+  test('skips guardian actor sessions (self-approve)', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext: GuardianRuntimeContext = {
+      sourceChannel: 'telegram',
+      trustClass: 'guardian',
+      guardianExternalUserId: 'guardian-1',
+    };
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('skipped' in result && result.skipped).toBe(true);
+    if ('skipped' in result) {
+      expect(result.reason).toBe('not_trusted_contact');
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('skips unknown actor sessions', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext: GuardianRuntimeContext = {
+      sourceChannel: 'telegram',
+      trustClass: 'unknown',
+    };
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('skipped' in result && result.skipped).toBe(true);
+    if ('skipped' in result) {
+      expect(result.reason).toBe('not_trusted_contact');
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('skips when guardian identity is missing', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext({
+      guardianExternalUserId: undefined,
+    });
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('skipped' in result && result.skipped).toBe(true);
+    if ('skipped' in result) {
+      expect(result.reason).toBe('missing_guardian_identity');
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('skips when no guardian binding exists for channel', () => {
+    const canonicalRequest = makeCanonicalRequest({ sourceChannel: 'sms' });
+    const guardianContext = makeTrustedContactContext({
+      sourceChannel: 'sms',
+    });
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('skipped' in result && result.skipped).toBe(true);
+    if ('skipped' in result) {
+      expect(result.reason).toBe('no_guardian_binding');
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('sets correct attention hints for urgency', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    const hints = emittedSignals[0].attentionHints as Record<string, unknown>;
+    expect(hints.requiresAction).toBe(true);
+    expect(hints.urgency).toBe('high');
+    expect(hints.isAsyncBackground).toBe(false);
+    expect(hints.visibleInSourceNow).toBe(false);
+  });
+
+  test('uses dedupe key scoped to canonical request ID', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect(emittedSignals[0].dedupeKey).toBe(`tc-confirmation-request:${canonicalRequest.id}`);
+  });
+
+  test('creates vellum delivery row via onThreadCreated callback', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect(mockOnThreadCreatedCallbacks).toHaveLength(1);
+
+    // Simulate the broadcaster invoking onThreadCreated
+    mockOnThreadCreatedCallbacks[0]({
+      conversationId: 'guardian-thread-1',
+      title: 'Guardian question',
+      sourceEventName: 'guardian.question',
+    });
+
+    const deliveries = listCanonicalGuardianDeliveries(canonicalRequest.id);
+    expect(deliveries).toHaveLength(1);
+    expect(deliveries[0].destinationChannel).toBe('vellum');
+    expect(deliveries[0].destinationConversationId).toBe('guardian-thread-1');
+  });
+
+  test('uses custom assistantId when provided', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+      assistantId: 'custom-assistant',
+    });
+
+    // The mock only returns a binding for 'self', so 'custom-assistant'
+    // should fail with no_guardian_binding.
+    // Actually let's verify the signal uses the right assistantId.
+    // Since mock only has binding for 'self', this will skip.
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('passes assistantId to notification signal', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext();
+
+    // Use default assistantId 'self' which has a binding
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect(emittedSignals[0].assistantId).toBe('self');
+  });
+
+  test('includes requesterChatId as null when not provided', () => {
+    const canonicalRequest = makeCanonicalRequest();
+    const guardianContext = makeTrustedContactContext({
+      requesterChatId: undefined,
+    });
+
+    bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    const payload = emittedSignals[0].contextPayload as Record<string, unknown>;
+    expect(payload.requesterChatId).toBeNull();
+  });
+
+  test('skips when binding guardian identity does not match canonical request guardian', () => {
+    // Create a canonical request where guardianExternalUserId differs from the
+    // binding's guardianExternalUserId ('guardian-1' in the mock).
+    const canonicalRequest = makeCanonicalRequest({
+      guardianExternalUserId: 'old-guardian-who-was-rebound',
+    });
+    const guardianContext = makeTrustedContactContext();
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('skipped' in result && result.skipped).toBe(true);
+    if ('skipped' in result) {
+      expect(result.reason).toBe('binding_identity_mismatch');
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test('does not skip when canonical request guardian identity is null', () => {
+    // When guardianExternalUserId is null on the canonical request (e.g. desktop
+    // flow), the identity check should be skipped and the bridge should proceed.
+    const canonicalRequest = makeCanonicalRequest({
+      guardianExternalUserId: null,
+    });
+    const guardianContext = makeTrustedContactContext();
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      guardianContext,
+      conversationId: 'conv-1',
+      toolName: 'bash',
+    });
+
+    expect('bridged' in result && result.bridged).toBe(true);
+    expect(emittedSignals).toHaveLength(1);
+  });
+});