@vellumai/assistant 0.9.0-dev.202606181324.0804a69 → 0.9.0-dev.202606181513.fd39213

package/src/__tests__/relay-server.test.ts

@@ -16,6 +16,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import {
   afterAll,
+  beforeAll,
   beforeEach,
   describe,
   expect,
@@ -25,6 +26,10 @@ import {
   test,
 } from "bun:test";
 
+import { ADMISSION_FLOOR } from "@vellumai/gateway-client";
+
+import { TRUST_CLASS_RANK } from "../runtime/actor-trust-resolver.js";
+
 // ── Platform + logger mocks (must come before any source imports) ────
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -100,6 +105,80 @@ mock.module("../config/loader.js", () => ({
   loadConfig: () => mockConfig,
 }));
 
+// ── Channel admission policy reader mock ────────────────────────────
+//
+// handleSetup resolves the phone admission floor via this reader and forwards
+// it into routeSetup. Tests drive the floor by setting `mockAdmissionPolicy`
+// (or making the reader throw to exercise the fail-open guard).
+
+let mockAdmissionPolicy:
+  | import("@vellumai/gateway-client").AdmissionPolicy
+  | null = null;
+// Optional gate to hold the reader open mid-setup so tests can drive the
+// race window where a prompt arrives while handleSetup is still awaiting.
+let mockAdmissionGate: Promise<void> | null = null;
+// `mock.module` is process-global in Bun and leaks into sibling files that run
+// later in the same `bun test` invocation. channel-admission-reader.test.ts
+// imports the reader for real, so an unconditional stub here would feed it this
+// stub and break its assertions. Delegate to the real implementation unless
+// this file's tests are active (`admissionMockActive`, toggled in
+// beforeAll/afterAll). Snapshot the real exports into a plain object NOW,
+// before the stub registers — a module namespace is a live view, so reading
+// the real export after the stub installs would resolve back to the stub
+// (infinite recursion).
+const realChannelAdmissionReaderModule = {
+  ...(await import("../calls/channel-admission-reader.js")),
+};
+let admissionMockActive = false;
+mock.module("../calls/channel-admission-reader.js", () => ({
+  ...realChannelAdmissionReaderModule,
+  getChannelAdmissionPolicy: async (
+    channelType: import("../channels/types.js").ChannelId,
+  ) => {
+    if (!admissionMockActive) {
+      return realChannelAdmissionReaderModule.getChannelAdmissionPolicy(
+        channelType,
+      );
+    }
+    if (mockAdmissionGate) await mockAdmissionGate;
+    return mockAdmissionPolicy;
+  },
+}));
+
+// Real floor semantics, mirroring relay-setup-router.test.ts. The
+// enforceAdmissionPolicy mock omits the exempt-channel short-circuit so the
+// deny path can be exercised end-to-end regardless of channel.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realAdmissionPolicyModule = require("../runtime/routes/inbound-stages/admission-policy.js");
+mock.module("../runtime/routes/inbound-stages/admission-policy.js", () => ({
+  ...realAdmissionPolicyModule,
+  enforceAdmissionPolicy: (input: {
+    trustClass: string;
+    memberStatus: string | undefined;
+    policy: import("@vellumai/gateway-client").AdmissionPolicy;
+  }) => {
+    if (input.memberStatus === "blocked" || input.memberStatus === "revoked") {
+      return {
+        admitted: false,
+        reason:
+          input.memberStatus === "blocked" ? "member_blocked" : "member_revoked",
+        shouldChallenge: false,
+        effectivePolicy: input.policy,
+      };
+    }
+    const rank =
+      (TRUST_CLASS_RANK as Record<string, number>)[input.trustClass] ?? 0;
+    const floor = ADMISSION_FLOOR[input.policy];
+    if (rank >= floor) return { admitted: true };
+    return {
+      admitted: false,
+      reason: `admission_policy_${input.policy}`,
+      shouldChallenge: false,
+      effectivePolicy: input.policy,
+    };
+  },
+}));
+
 // ── TTS provider mocks (for call-speech-output) ─────────────────────
 
 let mockTtsProviderId: string = "elevenlabs";
@@ -240,7 +319,15 @@ import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
+// Activate the channel-admission-reader stub only while this file's tests run,
+// so the registered (process-global) mock delegates to the real module for
+// sibling files that load later in the same worker.
+beforeAll(() => {
+  admissionMockActive = true;
+});
+
 afterAll(() => {
+  admissionMockActive = false;
   resetDbForTesting();
 });
 
@@ -404,6 +491,8 @@ describe("relay-server", () => {
     activeRelayConnections.clear();
     mockUserReference = "my human";
     mockAssistantName = "Vellum";
+    mockAdmissionPolicy = null;
+    mockAdmissionGate = null;
     mockSendMessage.mockImplementation(createMockProviderResponse(["Hello"]));
     mockConfig.calls.verification.enabled = false;
     mockConfig.calls.verification.maxAttempts = 3;
@@ -840,6 +929,121 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("handleMessage: prompt arriving during setup (setting_up) is dropped", async () => {
+    ensureConversation("conv-relay-setting-up");
+    const session = createCallSession({
+      conversationId: "conv-relay-setting-up",
+      provider: "twilio",
+      fromNumber: "+15551111111",
+      toNumber: "+15552222222",
+    });
+
+    addTrustedVoiceContact("+15551111111");
+
+    const { ws, relay } = createMockWs(session.id);
+
+    // Hold the admission reader open so handleSetup stays in "setting_up".
+    let releaseGate: () => void = () => {};
+    mockAdmissionGate = new Promise<void>((resolve) => {
+      releaseGate = resolve;
+    });
+
+    // Fire setup without awaiting — it suspends inside getChannelAdmissionPolicy.
+    const setupPromise = relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_setting_up_123",
+        from: "+15551111111",
+        to: "+15552222222",
+      }),
+    );
+
+    // Let the setup task reach the await; state must be "setting_up".
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(relay.getConnectionState()).toBe("setting_up");
+
+    // A prompt arriving now must be dropped: no transcript, no fallback.
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "Wire me money",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+
+    const textMessages = ws.sentMessages
+      .map((m) => JSON.parse(m))
+      .filter((m: { type: string }) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").includes("still setting up")),
+    ).toBe(false);
+    expect(relay.getConversationHistory().length).toBe(0);
+    expect(
+      getMessages("conv-relay-setting-up").filter((m) => m.role === "user")
+        .length,
+    ).toBe(0);
+
+    // Release the reader and let setup finish.
+    releaseGate();
+    await setupPromise;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(relay.getConnectionState()).toBe("connected");
+
+    relay.destroy();
+  });
+
+  test("handleMessage: prompt after normal-call setup completes is handled", async () => {
+    ensureConversation("conv-relay-postsetup");
+    const session = createCallSession({
+      conversationId: "conv-relay-postsetup",
+      provider: "twilio",
+      fromNumber: "+15551111111",
+      toNumber: "+15552222222",
+    });
+
+    addTrustedVoiceContact("+15551111111");
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Sure, happy to help."]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_postsetup_123",
+        from: "+15551111111",
+        to: "+15552222222",
+      }),
+    );
+
+    // Setup completed normally → "connected".
+    expect(relay.getConnectionState()).toBe("connected");
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // A subsequent prompt routes to the controller (no "still setting up").
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "prompt",
+        voicePrompt: "Hello there",
+        lang: "en-US",
+        last: true,
+      }),
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const userMessages = getMessages("conv-relay-postsetup").filter(
+      (m) => m.role === "user",
+    );
+    expect(userMessages.length).toBeGreaterThan(0);
+    expect(relay.getConnectionState()).toBe("connected");
+
+    relay.destroy();
+  });
+
   // ── Interrupt handling ──────────────────────────────────────────
 
   test("handleMessage: interrupt message is handled without error", async () => {
@@ -2722,6 +2926,87 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  // ── Inbound admission floor (reader → routeSetup wiring) ───────────
+
+  test("admission floor: reader floor that excludes caller denies the call end-to-end", async () => {
+    ensureConversation("conv-admission-floor-deny");
+    const session = createCallSession({
+      conversationId: "conv-admission-floor-deny",
+      provider: "twilio",
+      fromNumber: "+15557776666",
+      toNumber: "+15551111111",
+    });
+
+    // A trusted contact (rank 3) is below the `guardian_only` floor (rank 4).
+    addTrustedVoiceContact("+15557776666");
+    mockAdmissionPolicy = "guardian_only";
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_admission_floor_deny",
+        from: "+15557776666",
+        to: "+15551111111",
+      }),
+    );
+
+    // Floor-excluded caller takes the deny path.
+    expect(relay.getConnectionState()).toBe("disconnecting");
+
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).toBe("failed");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").includes("not authorized")),
+    ).toBe(true);
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    relay.destroy();
+  });
+
+  test("admission floor: null policy from reader leaves the call flow unchanged", async () => {
+    ensureConversation("conv-admission-floor-null");
+    const session = createCallSession({
+      conversationId: "conv-admission-floor-null",
+      provider: "twilio",
+      fromNumber: "+15557776666",
+      toNumber: "+15551111111",
+    });
+
+    addTrustedVoiceContact("+15557776666");
+    mockAdmissionPolicy = null; // no floor supplied
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help you?"]),
+    );
+
+    const { relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_admission_floor_null",
+        from: "+15557776666",
+        to: "+15551111111",
+      }),
+    );
+
+    // Trusted contact proceeds normally — no deny.
+    expect(relay.getConnectionState()).toBe("connected");
+
+    const updated = getCallSession(session.id);
+    expect(updated!.status).toBe("in_progress");
+
+    relay.destroy();
+  });
+
   test("name capture flow: access request creates canonical request for guardian", async () => {
     ensureConversation("conv-access-req-canonical");
     const session = createCallSession({

package/src/__tests__/twilio-routes.test.ts

@@ -92,8 +92,21 @@ let mockRouteSetupResult: {
   },
 };
 
+// Captures the last context passed to routeSetup so preflight tests can
+// assert the resolved phone admission policy was threaded through.
+let lastRouteSetupCtx: Record<string, unknown> | null = null;
 mock.module("../calls/relay-setup-router.js", () => ({
-  routeSetup: () => mockRouteSetupResult,
+  routeSetup: (ctx: Record<string, unknown>) => {
+    lastRouteSetupCtx = ctx;
+    return mockRouteSetupResult;
+  },
+}));
+
+// Mock the phone channel admission reader used by the media-stream preflight.
+// Tests override mockAdmissionPolicy to exercise floor classification.
+let mockAdmissionPolicy: unknown = null;
+mock.module("../calls/channel-admission-reader.js", () => ({
+  getChannelAdmissionPolicy: async () => mockAdmissionPolicy,
 }));
 
 mock.module("../config/env.js", () => ({
@@ -454,6 +467,9 @@ describe("twilio webhook routes", () => {
     mockTwilioApiValidationBody = JSON.stringify({ sid: "AC_validated" });
     // Reset STT config to defaults between tests
     mockConfigObj.services.stt.provider = "deepgram" as any;
+    // Reset admission policy + captured routeSetup context between tests
+    mockAdmissionPolicy = null;
+    lastRouteSetupCtx = null;
     // Reset routeSetup mock to default normal_call
     mockRouteSetupResult = {
       outcome: { action: "normal_call", isInbound: true },
@@ -1228,6 +1244,70 @@ describe("twilio webhook routes", () => {
       expect(twiml).not.toContain("<ConversationRelay");
     });
 
+    test("media-stream: resolves the phone admission floor and threads it into the preflight routeSetup", async () => {
+      mockConfigObj.services.stt.provider = "openai-whisper" as any;
+      mockAdmissionPolicy = "guardian_only";
+      mockRouteSetupResult = {
+        outcome: { action: "normal_call", isInbound: true },
+        resolved: {
+          assistantId: "self",
+          isInbound: true,
+          otherPartyNumber: "+15559998888",
+          actorTrust: { trustClass: "guardian", memberRecord: null },
+        },
+      };
+
+      const session = createTestSession("conv-ms-floor-1", "CA_ms_floor_1");
+      const req = makeVoiceRequest(session.id, { CallSid: "CA_ms_floor_1" });
+
+      const res = await handleVoiceWebhook(req);
+      expect(res.status).toBe(200);
+
+      // The resolved floor was passed into the preflight routeSetup so its
+      // classification matches the real stream-start enforcement.
+      expect(lastRouteSetupCtx).not.toBeNull();
+      expect(lastRouteSetupCtx?.admissionPolicy).toBe("guardian_only");
+    });
+
+    test("media-stream: floor-denied caller classified deny still produces Stream TwiML (deny handled at stream level)", async () => {
+      mockConfigObj.services.stt.provider = "openai-whisper" as any;
+      mockAdmissionPolicy = "guardian_only";
+      // With the floor wired, the real router returns `deny` for a
+      // below-floor trusted_contact caller; the mock reflects that.
+      mockRouteSetupResult = {
+        outcome: {
+          action: "deny",
+          message:
+            "This number is not authorized to reach the assistant right now.",
+          logReason: "Inbound voice admission floor: guardian_only",
+        },
+        resolved: {
+          assistantId: "self",
+          isInbound: true,
+          otherPartyNumber: "+14155550000",
+          actorTrust: { trustClass: "trusted_contact", memberRecord: null },
+        },
+      };
+
+      const session = createTestSession(
+        "conv-ms-floor-deny-1",
+        "CA_ms_floor_deny_1",
+      );
+      const req = makeVoiceRequest(session.id, {
+        CallSid: "CA_ms_floor_deny_1",
+      });
+
+      const res = await handleVoiceWebhook(req);
+      expect(res.status).toBe(200);
+
+      // Policy was threaded; deny is supported on media-stream, so Stream
+      // TwiML is still produced (denial spoken + torn down at stream start).
+      expect(lastRouteSetupCtx?.admissionPolicy).toBe("guardian_only");
+      const twiml = await res.text();
+      expect(twiml).toContain("<Stream");
+      expect(twiml).not.toContain("<ConversationRelay");
+    });
+
     test("media-stream: deny setup proceeds with Stream TwiML (deny is handled at stream level)", async () => {
       mockConfigObj.services.stt.provider = "openai-whisper" as any;
       mockRouteSetupResult = {

package/src/calls/__tests__/channel-admission-reader.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Tests for the gateway-backed channel admission policy reader.
+ *
+ * The reader fails open (returns null = admit) so a gateway IPC failure can
+ * never block a live call. These tests pin that contract plus the TTL cache.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Controllable IPC mock ────────────────────────────────────────────────────
+
+type IpcHandler = (params?: Record<string, unknown>) => unknown;
+
+const ipcHandlers = new Map<string, IpcHandler>();
+const ipcCallLog: Array<{
+  method: string;
+  params?: Record<string, unknown>;
+  timeoutMs?: number;
+}> = [];
+
+mock.module("../../ipc/gateway-client.js", () => ({
+  ipcCall: async (
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number,
+  ) => {
+    ipcCallLog.push({ method, params, timeoutMs });
+    const handler = ipcHandlers.get(method);
+    return handler ? handler(params) : undefined;
+  },
+  ipcCallPersistent: async () => undefined,
+  resetPersistentClient: () => {},
+}));
+
+import {
+  _clearCacheForTesting,
+  getChannelAdmissionPolicy,
+} from "../channel-admission-reader.js";
+
+const METHOD = "get_channel_admission_policy";
+
+function countCalls(method: string): number {
+  return ipcCallLog.filter((c) => c.method === method).length;
+}
+
+describe("getChannelAdmissionPolicy", () => {
+  beforeEach(() => {
+    _clearCacheForTesting();
+    ipcHandlers.clear();
+    ipcCallLog.length = 0;
+  });
+
+  test("returns the gateway-resolved policy and caches it within the TTL", async () => {
+    ipcHandlers.set(METHOD, () => ({ policy: "guardian_only" }));
+
+    expect(await getChannelAdmissionPolicy("telegram")).toBe("guardian_only");
+    // Second call within TTL is served from cache — no extra IPC round-trip.
+    expect(await getChannelAdmissionPolicy("telegram")).toBe("guardian_only");
+    expect(countCalls(METHOD)).toBe(1);
+  });
+
+  test("bounds the IPC read with a short timeout so it fails open promptly", async () => {
+    ipcHandlers.set(METHOD, () => ({ policy: "guardian_only" }));
+
+    await getChannelAdmissionPolicy("telegram");
+
+    const call = ipcCallLog.find((c) => c.method === METHOD);
+    expect(call?.timeoutMs).toBe(1_000);
+  });
+
+  test("returns null when IPC transport fails (undefined)", async () => {
+    ipcHandlers.set(METHOD, () => undefined);
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+  });
+
+  test("returns null when the gateway explicitly resolves no policy", async () => {
+    ipcHandlers.set(METHOD, () => ({ policy: null }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+  });
+
+  test("returns null when the IPC call throws", async () => {
+    ipcHandlers.set(METHOD, () => {
+      throw new Error("socket exploded");
+    });
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+  });
+
+  test("returns null for an invalid policy string", async () => {
+    ipcHandlers.set(METHOD, () => ({ policy: "definitely-not-a-policy" }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+  });
+
+  test("caches the explicit no-enforcement (null) answer within the TTL", async () => {
+    // The gateway successfully said "no enforcement" — a real, cacheable answer.
+    ipcHandlers.set(METHOD, () => ({ policy: null }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+    expect(countCalls(METHOD)).toBe(1);
+  });
+
+  test("does NOT cache a transport failure (undefined) — re-consults the gateway", async () => {
+    // First setup: gateway hiccup → fail open to null, NOT cached.
+    ipcHandlers.set(METHOD, () => undefined);
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+
+    // Gateway recovers with a restrictive policy: the next setup must re-attempt
+    // the IPC (not serve a stale fail-open null) and honor the now-recovered floor.
+    ipcHandlers.set(METHOD, () => ({ policy: "guardian_only" }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBe("guardian_only");
+    expect(countCalls(METHOD)).toBe(2);
+  });
+
+  test("does NOT cache a thrown IPC error — re-consults the gateway", async () => {
+    ipcHandlers.set(METHOD, () => {
+      throw new Error("socket exploded");
+    });
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+
+    ipcHandlers.set(METHOD, () => ({ policy: "no_one" }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBe("no_one");
+    expect(countCalls(METHOD)).toBe(2);
+  });
+
+  test("does NOT cache a malformed shape — re-consults the gateway", async () => {
+    ipcHandlers.set(METHOD, () => ({ policy: "definitely-not-a-policy" }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBeNull();
+
+    ipcHandlers.set(METHOD, () => ({ policy: "guardian_only" }));
+    expect(await getChannelAdmissionPolicy("telegram")).toBe("guardian_only");
+    expect(countCalls(METHOD)).toBe(2);
+  });
+});