@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/__tests__/llm-usage-store.test.ts

@@ -779,6 +779,31 @@ describe("getUsageDayBuckets", () => {
     expect(buckets[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
     expect(buckets[0].eventCount).toBe(2);
   });
+
+  test("collapses many events within a sub-bucket span without losing totals", () => {
+    // The read path pre-aggregates events into 15-minute UTC buckets in SQL
+    // before local-time bucketing. Many events inside one such window must
+    // still sum exactly, and events split across the 15-minute boundary but
+    // within the same local day must land in the same day bucket.
+    const windowStart = utcMs(2025, 3, 1, 10); // 10:00:00 UTC
+    for (let i = 0; i < 50; i++) {
+      // Spread across ~16 minutes so the events straddle a 15-minute boundary.
+      insertEventAt(windowStart + i * 20_000, {
+        inputTokens: 2,
+        outputTokens: 1,
+      });
+    }
+
+    const buckets = getUsageDayBuckets({
+      from: utcMs(2025, 3, 1),
+      to: utcMs(2025, 3, 2),
+    });
+    expect(buckets).toHaveLength(1);
+    expect(buckets[0].date).toBe("2025-03-01");
+    expect(buckets[0].totalInputTokens).toBe(100);
+    expect(buckets[0].totalOutputTokens).toBe(50);
+    expect(buckets[0].eventCount).toBe(50);
+  });
 });
 
 describe("getUsageDayBuckets — timezone-aware", () => {

package/src/__tests__/media-stream-server-integration.test.ts

@@ -176,6 +176,22 @@ mock.module("../calls/channel-admission-reader.js", () => ({
   getChannelAdmissionPolicy: mockGetChannelAdmissionPolicy,
 }));
 
+// Mock the inbound trust reader. handleStart awaits this and threads the
+// verdict into routeSetup so the media-stream transport enforces the same
+// gateway ACL as ConversationRelay. Tests override mockInboundVerdict.
+let mockInboundVerdict: unknown = null;
+const mockGetInboundTrustVerdict = jest.fn(
+  async (_args?: Record<string, unknown>) => mockInboundVerdict,
+);
+mock.module("../calls/inbound-trust-reader.js", () => ({
+  getInboundTrustVerdict: mockGetInboundTrustVerdict,
+  getPhoneCallerVerdict: (otherPartyNumber: string | undefined) =>
+    mockGetInboundTrustVerdict({
+      channelType: "phone",
+      actorExternalId: otherPartyNumber || undefined,
+    }),
+}));
+
 // Mock the actor trust resolver (used by handleStart to derive trust context)
 mock.module("../runtime/actor-trust-resolver.js", () => ({
   toTrustContext: jest.fn(() => ({
@@ -356,6 +372,8 @@ beforeEach(() => {
   mockGetChannelAdmissionPolicy.mockClear();
   mockAdmissionPolicy = null;
   mockAdmissionGate = null;
+  mockGetInboundTrustVerdict.mockClear();
+  mockInboundVerdict = null;
   // Reset routeSetup to default normal_call
   mockRouteSetupResult = {
     outcome: { action: "normal_call" as const, isInbound: true },
@@ -1535,4 +1553,113 @@ describe("media-stream setup outcome scenarios", () => {
       expect(speakSystemPrompt).not.toHaveBeenCalled();
     });
   });
+
+  // ── Gateway trust verdict ──────────────────────────────────────────
+  // handleStart fetches getInboundTrustVerdict for the inbound caller and
+  // threads it into routeSetup, so the media-stream transport enforces the
+  // same gateway ACL as ConversationRelay. routeSetup itself decides
+  // verdict-vs-local; these tests assert the verdict is fetched and passed.
+
+  describe("gateway trust verdict", () => {
+    test("fetches the inbound caller's verdict and threads it into routeSetup", async () => {
+      mockInboundVerdict = {
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        status: "verified",
+        policy: "allow",
+        resolutionFailed: false,
+      };
+
+      const mockWs = createMockWs();
+      mockSessions.set("call-verdict-thread-1", {
+        id: "call-verdict-thread-1",
+        conversationId: "conv-verdict-thread-1",
+        status: "initiated",
+        task: null,
+        startedAt: null,
+        fromNumber: "+14155550000",
+        toNumber: "+15550001111",
+      });
+
+      const session = new MediaStreamCallSession(
+        mockWs.ws,
+        "call-verdict-thread-1",
+      );
+      session.handleMessage(makeStartMessage());
+      await session.whenSetupSettled();
+
+      // Verdict fetched for the inbound caller (from number) on the phone channel.
+      expect(mockGetInboundTrustVerdict).toHaveBeenCalledWith({
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+      });
+      // Verdict threaded into routeSetup.
+      expect(routeSetup).toHaveBeenCalledWith(
+        expect.objectContaining({ verdict: mockInboundVerdict }),
+      );
+    });
+
+    test("a blocked/denied member verdict is enforced (deny) on the media-stream transport", async () => {
+      // The real router returns `deny` for a member verdict whose ACL is
+      // blocked/revoked/deny; the mock reflects that outcome here.
+      mockInboundVerdict = {
+        channelType: "phone",
+        actorExternalId: "+14155550000",
+        contactId: "contact-1",
+        channelId: "channel-1",
+        status: "blocked",
+        policy: "deny",
+        resolutionFailed: false,
+      };
+      mockRouteSetupResult = {
+        outcome: {
+          action: "deny",
+          message:
+            "This number is not authorized to reach the assistant right now.",
+          logReason: "Inbound voice ACL: member blocked",
+        },
+        resolved: {
+          assistantId: "self",
+          isInbound: true,
+          otherPartyNumber: "+14155550000",
+          actorTrust: { trustClass: "unknown", memberRecord: null },
+        },
+      };
+
+      const mockWs = createMockWs();
+      mockSessions.set("call-verdict-deny-1", {
+        id: "call-verdict-deny-1",
+        conversationId: "conv-verdict-deny-1",
+        status: "initiated",
+        task: null,
+        startedAt: null,
+        fromNumber: "+14155550000",
+        toNumber: "+15550001111",
+      });
+
+      const session = new MediaStreamCallSession(
+        mockWs.ws,
+        "call-verdict-deny-1",
+      );
+      session.handleMessage(makeStartMessage());
+      await session.whenSetupSettled();
+
+      // Verdict was passed into routeSetup, which denied the caller.
+      expect(routeSetup).toHaveBeenCalledWith(
+        expect.objectContaining({ verdict: mockInboundVerdict }),
+      );
+      expect(speakSystemPrompt).toHaveBeenCalledWith(
+        expect.anything(),
+        "This number is not authorized to reach the assistant right now.",
+      );
+      expect(updateCallSession).toHaveBeenCalledWith(
+        "call-verdict-deny-1",
+        expect.objectContaining({ status: "failed" }),
+      );
+      expect(registerCallController).not.toHaveBeenCalled();
+      expect(mockStartInitialGreeting).not.toHaveBeenCalled();
+    });
+  });
 });

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

@@ -19,6 +19,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // bindings resolve through the mocks.
 const updateMessageMetadataMock = mock((_id: string, _updates: unknown) => {});
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   updateMessageMetadata: updateMessageMetadataMock,
 }));
 

package/src/__tests__/messaging-send-tool.test.ts

@@ -79,6 +79,8 @@ const getBindingByChannelChatMock = mock(
 );
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: addMessageMock,
   getConversation: getConversationMock,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),

package/src/__tests__/migration-import-from-url.test.ts

@@ -421,8 +421,8 @@ describe("handleMigrationImport — JSON {url} body", () => {
 describe("handleMigrationImport — no-swap path omits newer-migration warning", () => {
   test("credentials-only bundle does not inherit live-DB migration warnings", async () => {
     // Seed the live workspace DB with a step:* checkpoint that's NOT
-    // in the registry. validateMigrationState treats this as a "newer
-    // version" and would otherwise push a warning into the report. With
+    // in the known step list. validateMigrationState treats this as a
+    // "newer version" and would otherwise push a warning into the report. With
     // the gate in appendNewerMigrationWarningsIfAny the warning must be
     // suppressed when the import didn't modify the workspace.
     const dbDir = join(testWorkspaceRoot, "data", "db");

package/src/__tests__/native-web-search.test.ts

@@ -95,6 +95,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: () => null,
   updateMessageContent: () => {},

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

@@ -61,6 +61,36 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
+// Guardian identity for the access request resolves via the gateway delivery
+// reader, not the local contacts DB. Seed it per-test via seedGatewayGuardian.
+interface GatewayGuardian {
+  channelType: string;
+  contactId: string;
+  principalId?: string | null;
+  displayName?: string | null;
+  address: string;
+  externalChatId?: string | null;
+  status: string;
+  verifiedAt?: number | null;
+}
+let gatewayGuardians: GatewayGuardian[] = [];
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => gatewayGuardians,
+  guardianForChannel: (list: GatewayGuardian[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+function seedGatewayGuardian(g: Partial<GatewayGuardian> & {
+  channelType: string;
+  address: string;
+}): void {
+  gatewayGuardians.push({
+    contactId: `c-${g.channelType}`,
+    status: "active",
+    ...g,
+  });
+}
+
 import {
   listCanonicalGuardianDeliveries,
   listCanonicalGuardianRequests,
@@ -95,6 +125,7 @@ function resetState(): string {
   db.run("DELETE FROM contacts");
   emitSignalCalls.length = 0;
   deliverReplyCalls.length = 0;
+  gatewayGuardians = [];
   mockEmitResult = {
     signalId: "mock-signal-id",
     deduplicated: false,
@@ -102,8 +133,15 @@ function resetState(): string {
     reason: "mock",
     deliveryResults: [],
   };
-  // Seed the vellum anchor binding (gateway does this at startup in production)
+  // Seed the vellum anchor binding in the gateway list (gateway does this at
+  // startup in production). The DB write mirrors it for any local INFO reads.
   const principalId = `vellum-principal-${crypto.randomUUID()}`;
+  seedGatewayGuardian({
+    channelType: "vellum",
+    address: principalId,
+    principalId,
+    displayName: principalId,
+  });
   createGuardianBinding({
     channel: "vellum",
     guardianExternalUserId: principalId,
@@ -172,6 +210,12 @@ describe("non-member access request notification", () => {
 
   test("guardian is notified when a non-member messages and a guardian binding exists", async () => {
     // Set up a guardian binding for this channel using the anchor principal
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-789",
+      externalChatId: "guardian-chat-789",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
@@ -217,6 +261,12 @@ describe("non-member access request notification", () => {
   });
 
   test("no duplicate approval requests for repeated messages from same non-member", async () => {
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-789",
+      externalChatId: "guardian-chat-789",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-789",
@@ -289,6 +339,12 @@ describe("non-member access request notification", () => {
     // Only a voice guardian binding exists — no Telegram binding.
     // Since cross-channel fallback was removed, the access request resolves
     // to the assistant's vellum anchor identity instead.
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice-user",
+      externalChatId: "guardian-voice-chat",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "guardian-voice-user",
@@ -351,8 +407,8 @@ describe("access-request-helper unit tests", () => {
     anchorPrincipalId = resetState();
   });
 
-  test("notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -372,8 +428,8 @@ describe("access-request-helper unit tests", () => {
     expect(pending.length).toBe(0);
   });
 
-  test("notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -400,8 +456,14 @@ describe("access-request-helper unit tests", () => {
     expect(emitSignalCalls.length).toBe(1);
   });
 
-  test("notifyGuardianOfAccessRequest falls back to assistant-anchored vellum identity when source-channel binding is missing", () => {
+  test("notifyGuardianOfAccessRequest falls back to assistant-anchored vellum identity when source-channel binding is missing", async () => {
     // Only voice binding exists
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice",
+      externalChatId: "voice-chat",
+      principalId: "test-principal-id",
+    });
     createGuardianBinding({
       channel: "phone",
       guardianExternalUserId: "guardian-voice",
@@ -410,7 +472,7 @@ describe("access-request-helper unit tests", () => {
       verifiedVia: "test",
     });
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "tg-chat",
@@ -435,8 +497,20 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("vellum");
   });
 
-  test("notifyGuardianOfAccessRequest prefers source-channel binding over vellum anchor", () => {
+  test("notifyGuardianOfAccessRequest prefers source-channel binding over vellum anchor", async () => {
     // Both Telegram and voice bindings exist with the anchor principal
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-tg",
+      externalChatId: "tg-chat",
+      principalId: anchorPrincipalId,
+    });
+    seedGatewayGuardian({
+      channelType: "phone",
+      address: "guardian-voice",
+      externalChatId: "voice-chat",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-tg",
@@ -452,7 +526,7 @@ describe("access-request-helper unit tests", () => {
       verifiedVia: "test",
     });
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -477,8 +551,100 @@ describe("access-request-helper unit tests", () => {
     expect(payload.guardianBindingChannel).toBe("telegram");
   });
 
-  test("notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest falls back to local source-channel binding when gateway delivery is empty", async () => {
+    // Gateway delivery read yields nothing (restart/timeout/malformed IPC).
+    gatewayGuardians = [];
+    // Local dual-written mirror still has the vellum anchor + telegram binding.
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "guardian-tg",
+      guardianDeliveryChatId: "tg-chat",
+      guardianPrincipalId: anchorPrincipalId,
+      verifiedVia: "test",
+    });
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-123",
+      actorExternalId: "unknown-user",
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+    // Request is decidable: local read supplied the principal + source binding.
+    expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
+    expect(pending[0].guardianExternalUserId).toBe("guardian-tg");
+
+    const payload = emitSignalCalls[0].contextPayload as Record<
+      string,
+      unknown
+    >;
+    expect(payload.guardianBindingChannel).toBe("telegram");
+  });
+
+  test("notifyGuardianOfAccessRequest falls back to local vellum anchor when gateway delivery is empty", async () => {
+    // Gateway empty; only the local vellum anchor from resetState remains.
+    gatewayGuardians = [];
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-123",
+      actorExternalId: "unknown-user",
+    });
+
+    expect(result.notified).toBe(true);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+    // Decidable via the local vellum anchor principal.
+    expect(pending[0].guardianPrincipalId).toBe(anchorPrincipalId);
+
+    const payload = emitSignalCalls[0].contextPayload as Record<
+      string,
+      unknown
+    >;
+    expect(payload.guardianBindingChannel).toBe("vellum");
+  });
+
+  test("notifyGuardianOfAccessRequest does not create a decisionable request when both gateway and local reads are empty", async () => {
+    // Genuinely unbound assistant: gateway empty AND no local binding. Prior
+    // behavior rejects creation of a decisionable request without a principal.
+    gatewayGuardians = [];
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+
+    await expect(
+      notifyGuardianOfAccessRequest({
+        canonicalAssistantId: "self",
+        sourceChannel: "telegram",
+        conversationExternalId: "chat-123",
+        actorExternalId: "unknown-user",
+      }),
+    ).rejects.toThrow();
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "unknown-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(0);
+  });
+
+  test("notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15559998888",
@@ -508,8 +674,8 @@ describe("access-request-helper unit tests", () => {
     expect(pending.length).toBe(1);
   });
 
-  test("notifyGuardianOfAccessRequest includes requestCode in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest includes requestCode in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -529,8 +695,8 @@ describe("access-request-helper unit tests", () => {
     expect((payload.requestCode as string).length).toBe(6);
   });
 
-  test("notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload", () => {
-    const result = notifyGuardianOfAccessRequest({
+  test("notifyGuardianOfAccessRequest includes previousMemberStatus in contextPayload", async () => {
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
@@ -570,7 +736,7 @@ describe("access-request-helper unit tests", () => {
       ],
     };
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15556667777",
@@ -603,6 +769,12 @@ describe("access-request-helper unit tests", () => {
     // Set up a telegram guardian binding with the anchor principal so
     // guardianResolutionSource resolves to "source-channel-contact" and
     // sameChannelOnly is true.
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-456",
+      externalChatId: "guardian-chat-456",
+      principalId: anchorPrincipalId,
+    });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "guardian-user-456",
@@ -625,7 +797,7 @@ describe("access-request-helper unit tests", () => {
       ],
     };
 
-    const result = notifyGuardianOfAccessRequest({
+    const result = await notifyGuardianOfAccessRequest({
       canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",

package/src/__tests__/notification-broadcaster.test.ts

@@ -24,6 +24,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => null,
+}));
+
 // Mock destination-resolver to return a destination for every requested channel.
 // External channels (telegram, slack) include bindingContext.
 mock.module("../notifications/destination-resolver.js", () => ({