@vellumai/assistant 0.4.5 → 0.4.7

package/src/__tests__/memory-retrieval.benchmark.test.ts

@@ -31,16 +31,13 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-// Simulated network delay for semantic search (ms). When > 0, the mock
-// semantic search sleeps for this duration before returning, simulating the
-// Qdrant network round-trip that early termination is designed to skip.
-let semanticSearchDelayMs = 0;
+// Counter for semantic search invocations — used to verify early termination
+// skips the call entirely rather than relying on flaky wall-clock comparisons.
+let semanticSearchCallCount = 0;
 
 mock.module('../memory/search/semantic.js', () => ({
   semanticSearch: async () => {
-    if (semanticSearchDelayMs > 0) {
-      await Bun.sleep(semanticSearchDelayMs);
-    }
+    semanticSearchCallCount++;
     return [];
   },
   isQdrantConnectionError: () => false,
@@ -305,15 +302,11 @@ describe('Memory retrieval benchmark', () => {
     expect(recall.selectedCount).toBeGreaterThan(0);
   });
 
-  test('early termination is measurably faster than baseline', async () => {
-    const conversationId = 'conv-bench-et-delta';
+  test('early termination skips semantic search entirely', async () => {
+    const conversationId = 'conv-bench-et-skip';
     const now = 1_700_500_000_000;
     seedMemoryItems(conversationId, 500, now);
 
-    // Simulate the Qdrant network round-trip that ET is designed to skip.
-    // Use 100ms to dominate over variable CPU-bound work on slower hosts.
-    semanticSearchDelayMs = 100;
-
     const query = 'What do we know about topic-5 and keyword-3?';
 
     const etConfig: AssistantConfig = {
@@ -363,40 +356,22 @@ describe('Memory retrieval benchmark', () => {
       },
     };
 
-    try {
-      // Warm up to avoid cold-start bias
-      await buildMemoryRecall(query, conversationId, etConfig);
-      await buildMemoryRecall(query, conversationId, noEtConfig);
-
-      const iterations = 5;
-      const etTimes: number[] = [];
-      const baselineTimes: number[] = [];
-
-      for (let i = 0; i < iterations; i++) {
-        const t0 = performance.now();
-        const etRecall = await buildMemoryRecall(query, conversationId, etConfig);
-        etTimes.push(performance.now() - t0);
-        expect(etRecall.earlyTerminated).toBe(true);
-
-        const t1 = performance.now();
-        const baselineRecall = await buildMemoryRecall(query, conversationId, noEtConfig);
-        baselineTimes.push(performance.now() - t1);
-        expect(baselineRecall.earlyTerminated).toBe(false);
-      }
-
-      etTimes.sort((a, b) => a - b);
-      baselineTimes.sort((a, b) => a - b);
-      const medianEt = etTimes[Math.floor(iterations / 2)];
-      const medianBaseline = baselineTimes[Math.floor(iterations / 2)];
-
-      // ET skips the mocked network delay, so it should be measurably faster.
-      // Use a 15% threshold to tolerate slower CI hosts where CPU-bound work
-      // takes longer relative to the fixed mock delay.
-      const speedup = 1 - medianEt / medianBaseline;
-      expect(speedup).toBeGreaterThanOrEqual(0.15);
-    } finally {
-      semanticSearchDelayMs = 0;
-    }
+    // Run with ET enabled — semantic search should be skipped
+    semanticSearchCallCount = 0;
+    const etRecall = await buildMemoryRecall(query, conversationId, etConfig);
+    const etCalls = semanticSearchCallCount;
+
+    expect(etRecall.earlyTerminated).toBe(true);
+    expect(etRecall.semanticHits).toBe(0);
+    expect(etCalls).toBe(0);
+
+    // Run without ET — semantic search should be invoked
+    semanticSearchCallCount = 0;
+    const baselineRecall = await buildMemoryRecall(query, conversationId, noEtConfig);
+    const baselineCalls = semanticSearchCallCount;
+
+    expect(baselineRecall.earlyTerminated).toBe(false);
+    expect(baselineCalls).toBeGreaterThan(0);
   });
 
   test('recall.latencyMs tracks wall-clock within 50% tolerance', async () => {

package/src/__tests__/no-is-trusted-guard.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Guard test: `isTrusted` must not appear in production code.
+ *
+ * The authorization model was migrated from a boolean `isTrusted` flag to
+ * principal-based authorization (`guardianPrincipalId` matching). This guard
+ * ensures the legacy pattern is never reintroduced in production source files.
+ *
+ * The invariant: `actor.guardianPrincipalId === request.guardianPrincipalId`
+ * (with cross-channel fallback via the vellum canonical principal).
+ *
+ * Allowed exceptions:
+ *   - Variable names like `isTrustedActor` or `isTrustedContact` that refer
+ *     to trust-class checks (e.g. `trustClass === 'guardian'`), NOT to a
+ *     boolean `isTrusted` property on ActorContext.
+ *   - Test files (__tests__/) — may reference `isTrusted` in test descriptions
+ *     or comments about the migration.
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+const repoRoot = resolve(__dirname, '..', '..', '..');
+
+describe('isTrusted guard', () => {
+  test('isTrusted property must not exist in production ActorContext usage', () => {
+    // Search for `isTrusted` used as a property (e.g., `.isTrusted`, `isTrusted:`,
+    // `isTrusted =`) in production TypeScript files, excluding tests, node_modules,
+    // and the allowed trust-class variable pattern.
+    const raw = execSync(
+      [
+        'grep -rn "isTrusted" assistant/src/ --include="*.ts"',
+        'grep -v "__tests__"',
+        'grep -v "node_modules"',
+      ].join(' | ') + ' || true',
+      { encoding: 'utf-8', cwd: repoRoot },
+    );
+
+    // Filter in JS: strip allowed token names from each line, then check if
+    // `isTrusted` still appears. This avoids the grep -v approach which could
+    // mask forbidden usage on lines that also contain allowed tokens.
+    const ALLOWED_TOKENS = ['isTrustedActor', 'isTrustedContact', 'isTrustedTrustClass'];
+    const offending = raw
+      .trim()
+      .split('\n')
+      .filter((line) => {
+        if (!line) return false;
+        let stripped = line;
+        for (const token of ALLOWED_TOKENS) {
+          stripped = stripped.replaceAll(token, '');
+        }
+        return stripped.includes('isTrusted');
+      });
+
+    if (offending.length > 0) {
+      throw new Error(
+        'Found `isTrusted` references in production code. Authorization must use ' +
+        '`guardianPrincipalId` matching instead. Offending lines:\n' +
+        offending.join('\n'),
+      );
+    }
+  });
+
+  test('ActorContext interface must not declare isTrusted field', () => {
+    // Verify the ActorContext type definition does not include isTrusted
+    const result = execSync(
+      [
+        'grep -n "isTrusted" assistant/src/approvals/guardian-request-resolvers.ts',
+        'true',
+      ].join(' || '),
+      { encoding: 'utf-8', cwd: repoRoot },
+    );
+
+    expect(result.trim()).toBe('');
+  });
+});

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

@@ -138,12 +138,12 @@ function buildInboundRequest(overrides: Record<string, unknown> = {}): Request {
   const body: Record<string, unknown> = {
     sourceChannel: 'telegram',
     interface: 'telegram',
-    externalChatId: 'chat-123',
+    conversationExternalId: 'chat-123',
     externalMessageId: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     content: 'Hello, can I use this assistant?',
-    senderExternalUserId: 'user-unknown-456',
-    senderName: 'Alice Unknown',
-    senderUsername: 'alice_unknown',
+    actorExternalId: 'user-unknown-456',
+    actorDisplayName: 'Alice Unknown',
+    actorUsername: 'alice_unknown',
     replyCallbackUrl: 'http://localhost:7830/deliver/telegram',
     ...overrides,
   };
@@ -188,6 +188,7 @@ describe('non-member access request notification', () => {
       channel: 'telegram',
       guardianExternalUserId: 'guardian-user-789',
       guardianDeliveryChatId: 'guardian-chat-789',
+      guardianPrincipalId: 'test-principal-id',
     });
 
     const req = buildInboundRequest();
@@ -206,8 +207,8 @@ describe('non-member access request notification', () => {
     expect(emitSignalCalls[0].sourceEventName).toBe('ingress.access_request');
     expect(emitSignalCalls[0].sourceChannel).toBe('telegram');
     const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
-    expect(payload.senderExternalUserId).toBe('user-unknown-456');
-    expect(payload.senderName).toBe('Alice Unknown');
+    expect(payload.actorExternalId).toBe('user-unknown-456');
+    expect(payload.actorDisplayName).toBe('Alice Unknown');
 
     // A canonical access request was created
     const pending = listCanonicalGuardianRequests({
@@ -229,6 +230,7 @@ describe('non-member access request notification', () => {
       channel: 'telegram',
       guardianExternalUserId: 'guardian-user-789',
       guardianDeliveryChatId: 'guardian-chat-789',
+      guardianPrincipalId: 'test-principal-id',
     });
 
     // First message
@@ -258,9 +260,9 @@ describe('non-member access request notification', () => {
     expect(pending.length).toBe(1);
   });
 
-  test('access request is created and signal emitted even without same-channel guardian binding', async () => {
-    // No guardian binding on any channel — access request should still be
-    // created and notification signal emitted (null guardianExternalUserId).
+  test('access request is created with self-healed principal even without same-channel guardian binding', async () => {
+    // No guardian binding on any channel — self-heal creates a vellum binding
+    // so the access_request (now decisionable) has a guardianPrincipalId.
     const req = buildInboundRequest();
     const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
     const json = await resp.json() as Record<string, unknown>;
@@ -276,7 +278,7 @@ describe('non-member access request notification', () => {
     expect(emitSignalCalls.length).toBe(1);
     expect(emitSignalCalls[0].sourceEventName).toBe('ingress.access_request');
 
-    // Canonical request was created with null guardianExternalUserId
+    // Canonical request was created with a self-healed principal
     const pending = listCanonicalGuardianRequests({
       status: 'pending',
       requesterExternalUserId: 'user-unknown-456',
@@ -284,7 +286,9 @@ describe('non-member access request notification', () => {
       kind: 'access_request',
     });
     expect(pending.length).toBe(1);
-    expect(pending[0].guardianExternalUserId).toBeNull();
+    // Self-heal bootstraps a vellum binding — guardianExternalUserId is now set
+    expect(pending[0].guardianExternalUserId).toBeDefined();
+    expect(pending[0].guardianPrincipalId).toBeDefined();
   });
 
   test('cross-channel fallback: SMS guardian binding resolves for Telegram access request', async () => {
@@ -294,6 +298,7 @@ describe('non-member access request notification', () => {
       channel: 'sms',
       guardianExternalUserId: 'guardian-sms-user',
       guardianDeliveryChatId: 'guardian-sms-chat',
+      guardianPrincipalId: 'test-principal-id',
     });
 
     const req = buildInboundRequest();
@@ -319,21 +324,21 @@ describe('non-member access request notification', () => {
     expect(pending[0].guardianExternalUserId).toBe('guardian-sms-user');
   });
 
-  test('no notification when senderExternalUserId is absent', async () => {
+  test('no notification when actorExternalId is absent', async () => {
     createBinding({
       assistantId: 'self',
       channel: 'telegram',
       guardianExternalUserId: 'guardian-user-789',
       guardianDeliveryChatId: 'guardian-chat-789',
+      guardianPrincipalId: 'test-principal-id',
     });
 
-    // Message without senderExternalUserId — can't identify the requester.
-    // The ACL check requires senderExternalUserId to look up members,
-    // so without it the non-member gate is bypassed entirely.
+    // Message without actorExternalId — the handler returns BAD_REQUEST.
     const req = buildInboundRequest({
-      senderExternalUserId: undefined,
+      actorExternalId: undefined,
     });
-    await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    expect(resp.status).toBe(400);
 
     // No access request notification should fire (no identity to notify about)
     expect(emitSignalCalls.length).toBe(0);
@@ -345,12 +350,12 @@ describe('access-request-helper unit tests', () => {
     resetState();
   });
 
-  test('notifyGuardianOfAccessRequest returns no_sender_id when senderExternalUserId is absent', () => {
+  test('notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: undefined,
+      conversationExternalId: 'chat-123',
+      actorExternalId: undefined,
     });
 
     expect(result.notified).toBe(false);
@@ -363,13 +368,13 @@ describe('access-request-helper unit tests', () => {
     expect(pending.length).toBe(0);
   });
 
-  test('notifyGuardianOfAccessRequest creates request with null guardianExternalUserId when no binding exists', () => {
+  test('notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: 'unknown-user',
-      senderName: 'Bob',
+      conversationExternalId: 'chat-123',
+      actorExternalId: 'unknown-user',
+      actorDisplayName: 'Bob',
     });
 
     expect(result.notified).toBe(true);
@@ -383,7 +388,9 @@ describe('access-request-helper unit tests', () => {
       kind: 'access_request',
     });
     expect(pending.length).toBe(1);
-    expect(pending[0].guardianExternalUserId).toBeNull();
+    // Self-heal bootstraps a vellum binding
+    expect(pending[0].guardianExternalUserId).toBeDefined();
+    expect(pending[0].guardianPrincipalId).toBeDefined();
 
     // Signal was emitted
     expect(emitSignalCalls.length).toBe(1);
@@ -396,13 +403,14 @@ describe('access-request-helper unit tests', () => {
       channel: 'sms',
       guardianExternalUserId: 'guardian-sms',
       guardianDeliveryChatId: 'sms-chat',
+      guardianPrincipalId: 'test-principal-id',
     });
 
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'tg-chat',
-      senderExternalUserId: 'unknown-tg-user',
+      conversationExternalId: 'tg-chat',
+      actorExternalId: 'unknown-tg-user',
     });
 
     expect(result.notified).toBe(true);
@@ -427,19 +435,21 @@ describe('access-request-helper unit tests', () => {
       channel: 'telegram',
       guardianExternalUserId: 'guardian-tg',
       guardianDeliveryChatId: 'tg-chat',
+      guardianPrincipalId: 'test-principal-tg',
     });
     createBinding({
       assistantId: 'self',
       channel: 'sms',
       guardianExternalUserId: 'guardian-sms',
       guardianDeliveryChatId: 'sms-chat',
+      guardianPrincipalId: 'test-principal-sms',
     });
 
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: 'unknown-user',
+      conversationExternalId: 'chat-123',
+      actorExternalId: 'unknown-user',
     });
 
     expect(result.notified).toBe(true);
@@ -457,13 +467,13 @@ describe('access-request-helper unit tests', () => {
     expect(payload.guardianBindingChannel).toBe('telegram');
   });
 
-  test('notifyGuardianOfAccessRequest for voice channel includes senderName in contextPayload', () => {
+  test('notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'voice',
-      externalChatId: '+15559998888',
-      senderExternalUserId: '+15559998888',
-      senderName: 'Alice Caller',
+      conversationExternalId: '+15559998888',
+      actorExternalId: '+15559998888',
+      actorDisplayName: 'Alice Caller',
     });
 
     expect(result.notified).toBe(true);
@@ -471,8 +481,8 @@ describe('access-request-helper unit tests', () => {
 
     const payload = emitSignalCalls[0].contextPayload as Record<string, unknown>;
     expect(payload.sourceChannel).toBe('voice');
-    expect(payload.senderName).toBe('Alice Caller');
-    expect(payload.senderExternalUserId).toBe('+15559998888');
+    expect(payload.actorDisplayName).toBe('Alice Caller');
+    expect(payload.actorExternalId).toBe('+15559998888');
     expect(payload.senderIdentifier).toBe('Alice Caller');
 
     // Canonical request should exist
@@ -489,9 +499,9 @@ describe('access-request-helper unit tests', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: 'unknown-user',
-      senderName: 'Test User',
+      conversationExternalId: 'chat-123',
+      actorExternalId: 'unknown-user',
+      actorDisplayName: 'Test User',
     });
 
     expect(result.notified).toBe(true);
@@ -507,9 +517,9 @@ describe('access-request-helper unit tests', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: 'revoked-user',
-      senderName: 'Revoked User',
+      conversationExternalId: 'chat-123',
+      actorExternalId: 'revoked-user',
+      actorDisplayName: 'Revoked User',
       previousMemberStatus: 'revoked',
     });
 
@@ -544,9 +554,9 @@ describe('access-request-helper unit tests', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'voice',
-      externalChatId: '+15556667777',
-      senderExternalUserId: '+15556667777',
-      senderName: 'Noah',
+      conversationExternalId: '+15556667777',
+      actorExternalId: '+15556667777',
+      actorDisplayName: 'Noah',
     });
 
     expect(result.notified).toBe(true);
@@ -584,9 +594,9 @@ describe('access-request-helper unit tests', () => {
     const result = notifyGuardianOfAccessRequest({
       canonicalAssistantId: 'self',
       sourceChannel: 'telegram',
-      externalChatId: 'chat-123',
-      senderExternalUserId: 'unknown-user',
-      senderName: 'Alice',
+      conversationExternalId: 'chat-123',
+      actorExternalId: 'unknown-user',
+      actorDisplayName: 'Alice',
     });
 
     expect(result.notified).toBe(true);