@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/reaction-intercept-member-verdict-warm.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Cold-cache member-reaction regression.
+ *
+ * Slack reactions carry the gateway-stamped verdict on `sourceMetadata` but
+ * skip `getInboundTrustVerdict`, which is what warms the member-verdict cache
+ * the sync trust resolver reads. `handleSlackReactionIntercept` therefore seeds
+ * the cache from the stamped verdict before the sync resolve, so an active
+ * non-guardian contact's reaction classifies as `trusted_contact` instead of
+ * failing closed to `unknown` (and being dropped) on a cold process.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const MEMBER_USER_ID = "U_MEMBER_COLD";
+const MEMBER_CONTACT_ID = "member-contact";
+const MEMBER_CHANNEL_ID = "member-channel";
+const SLACK_CHANNEL_ID = "C0MEMBERCOLD";
+
+const MEMBER_CONTACT = {
+  id: MEMBER_CONTACT_ID,
+  displayName: "Member",
+  notes: null,
+  lastInteraction: null,
+  interactionCount: 0,
+  createdAt: 0,
+  updatedAt: 0,
+  contactType: "human",
+  userFile: null,
+  channels: [
+    {
+      id: MEMBER_CHANNEL_ID,
+      contactId: MEMBER_CONTACT_ID,
+      type: "slack",
+      address: MEMBER_USER_ID,
+      isPrimary: false,
+      externalChatId: SLACK_CHANNEL_ID,
+      inviteId: null,
+      lastSeenAt: null,
+      interactionCount: 0,
+      lastInteraction: null,
+      updatedAt: null,
+      createdAt: 0,
+    },
+  ],
+};
+
+// No guardian for slack — the reactor is a member, not the guardian.
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async () => ({ guardians: [] }),
+}));
+
+// The reactor resolves to a local member channel by address.
+mock.module("../contacts/contact-store.js", () => ({
+  findContactByAddress: (_channelType: string, address: string) =>
+    address === MEMBER_USER_ID ? MEMBER_CONTACT : null,
+}));
+
+// Stub downstream side effects so the test isolates trust classification.
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-1" }),
+}));
+mock.module("../memory/delivery-crud.js", () => ({
+  recordInbound: () => ({
+    eventId: "evt-1",
+    conversationId: "conv-1",
+    accepted: true,
+    duplicate: false,
+  }),
+  clearPayload: () => {},
+  linkMessage: () => {},
+}));
+mock.module("../memory/delivery-status.js", () => ({
+  markProcessed: () => {},
+}));
+mock.module("../memory/external-conversation-store.js", () => ({
+  upsertBinding: () => {},
+}));
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  getDiskPressureStatus: () => ({ level: "ok" }),
+}));
+mock.module("../daemon/disk-pressure-policy.js", () => ({
+  classifyDiskPressureTurnPolicy: () => ({ action: "allow" }),
+}));
+
+let receivedTrustClass: string | undefined;
+mock.module(
+  "../runtime/routes/inbound-stages/guardian-reply-intercept.js",
+  () => ({
+    handleGuardianReplyIntercept: async (params: { trustClass: string }) => {
+      receivedTrustClass = params.trustClass;
+      return { response: { accepted: true, canonicalRouter: "applied" } };
+    },
+  }),
+);
+
+import { __resetMemberVerdictCacheForTest } from "../runtime/member-verdict-cache.js";
+import { handleSlackReactionIntercept } from "../runtime/routes/inbound-stages/reaction-intercept.js";
+
+function buildParams(withStampedVerdict: boolean) {
+  return {
+    callbackData: "reaction:white_check_mark",
+    sourceChannel: "slack" as const,
+    sourceInterface: "slack" as const,
+    conversationExternalId: SLACK_CHANNEL_ID,
+    externalMessageId: `${SLACK_CHANNEL_ID}:1700000000.2:cold`,
+    canonicalAssistantId: "assistant-1",
+    rawSenderId: MEMBER_USER_ID,
+    canonicalSenderId: MEMBER_USER_ID,
+    actorDisplayName: "Member",
+    actorUsername: undefined,
+    replyCallbackUrl: "http://localhost:7830/deliver/slack",
+    sourceMetadata: {
+      messageId: "1700000000.2",
+      chatType: "channel",
+      ...(withStampedVerdict
+        ? {
+            trustVerdict: {
+              trustClass: "trusted_contact",
+              canonicalSenderId: MEMBER_USER_ID,
+              contactId: MEMBER_CONTACT_ID,
+              channelId: MEMBER_CHANNEL_ID,
+              type: "slack",
+              address: MEMBER_USER_ID,
+              status: "active",
+              policy: "allow",
+            },
+          }
+        : {}),
+    } as never,
+    slackChannelName: "general",
+    approvalConversationGenerator: undefined,
+  };
+}
+
+describe("reaction intercept seeds the member-verdict cache from the stamped verdict", () => {
+  beforeEach(() => {
+    __resetMemberVerdictCacheForTest();
+    receivedTrustClass = undefined;
+  });
+
+  test("cold cache + stamped verdict: active member reaction classifies as trusted_contact", async () => {
+    const result = await handleSlackReactionIntercept(buildParams(true));
+
+    // Not dropped — the stamped verdict warmed the cache, so the sync resolve
+    // found the member as active.
+    expect(result.reaction).not.toBe("dropped_unknown_actor");
+    expect(receivedTrustClass).toBe("trusted_contact");
+  });
+
+  test("cold cache + no stamped verdict: same member reaction fails closed to unknown", async () => {
+    const result = await handleSlackReactionIntercept(buildParams(false));
+
+    // Negative control: with no stamped verdict and a cold cache, the member
+    // can't be classified, so the reaction is dropped — proving the warm above
+    // is load-bearing.
+    expect(result.reaction).toBe("dropped_unknown_actor");
+    expect(receivedTrustClass).toBeUndefined();
+  });
+});

package/src/__tests__/reaction-persistence.test.ts

@@ -42,9 +42,39 @@ mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+// Guardian identity resolves via the gateway delivery cache, not the local
+// contacts DB. Seed it per-test via seedGatewayGuardian so the guardian
+// reactor classifies as `trustClass === "guardian"`.
+interface GatewayGuardian {
+  channelType: string;
+  address: string;
+  principalId?: string | null;
+  externalChatId?: string | null;
+  status: string;
+}
+let gatewayGuardians: GatewayGuardian[] = [];
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => gatewayGuardians,
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) => {
+    if (!input?.channelTypes) return gatewayGuardians;
+    return gatewayGuardians.filter((g) =>
+      input.channelTypes!.includes(g.channelType),
+    );
+  },
+  guardianForChannel: (list: GatewayGuardian[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: GatewayGuardian[]) => list[0],
+}));
+
+function seedGatewayGuardian(g: Partial<GatewayGuardian> & {
+  channelType: string;
+  address: string;
+}): void {
+  gatewayGuardians.push({ status: "active", ...g });
+}
+
 import { eq } from "drizzle-orm";
 
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import type { Conversation } from "../daemon/conversation.js";
 import {
   createCanonicalGuardianDelivery,
@@ -60,7 +90,10 @@ import {
   isSlackReactionEvent,
   parseSlackReactionCallbackData,
 } from "../runtime/routes/inbound-stages/reaction-intercept.js";
-import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 await initializeDb();
@@ -81,10 +114,11 @@ function resetState(): void {
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
+  gatewayGuardians = [];
 }
 
 function seedActiveMember(): void {
-  upsertContactChannel({
+  seedContactChannel({
     sourceChannel: "slack",
     externalUserId: SLACK_USER_ID,
     externalChatId: SLACK_CHANNEL_ID,
@@ -406,6 +440,12 @@ const GUARDIAN_REACTION_TOOL = "execute_shell";
 const GUARDIAN_REACTION_INPUT = { command: "rm -rf /tmp/test" };
 
 function seedGuardianForChannel(): void {
+  seedGatewayGuardian({
+    channelType: "slack",
+    address: GUARDIAN_USER_ID,
+    principalId: GUARDIAN_USER_ID,
+    externalChatId: SLACK_CHANNEL_ID,
+  });
   createGuardianBinding({
     channel: "slack",
     guardianExternalUserId: GUARDIAN_USER_ID,
@@ -478,6 +518,7 @@ describe("guardian approval-by-reaction integration via handleChannelInbound", (
     db.run("DELETE FROM contacts");
     db.run("DELETE FROM canonical_guardian_requests");
     db.run("DELETE FROM canonical_guardian_deliveries");
+    gatewayGuardians = [];
     pendingInteractions.clear();
     msgCounter = 0;
   });
@@ -608,6 +649,12 @@ describe("reaction access control (no verification handshake)", () => {
     getDb().run("DELETE FROM channel_verification_sessions");
     // The assistant has a guardian (as in production); the reactors below are
     // different users.
+    seedGatewayGuardian({
+      channelType: "slack",
+      address: GUARDIAN_USER_ID,
+      principalId: GUARDIAN_USER_ID,
+      externalChatId: GUARDIAN_DM_CHAT,
+    });
     createGuardianBinding({
       channel: "slack",
       guardianExternalUserId: GUARDIAN_USER_ID,
@@ -655,7 +702,7 @@ describe("reaction access control (no verification handshake)", () => {
     // A pending contact classifies as `unverified_contact` — a known tier, so
     // its reactions are recorded. On a real message it would be re-challenged,
     // but a reaction must not trigger that.
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "slack",
       externalUserId: CONTACT_USER_ID,
       externalChatId: SLACK_CHANNEL_ID,

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

@@ -26,6 +26,8 @@ import {
   test,
 } from "bun:test";
 
+import { and, desc, eq } from "drizzle-orm";
+
 // ── Platform + logger mocks (must come before any source imports) ────
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -50,12 +52,32 @@ let inviteClaimCalls = 0;
 let inviteClaimGate: Promise<void> | null = null;
 mock.module("../ipc/gateway-client.js", () => ({
   ipcCall: async () => undefined,
-  ipcCallPersistent: async (method: string) => {
+  ipcCallPersistent: async (
+    method: string,
+    params?: Record<string, unknown>,
+  ) => {
     if (method === "record_invite_redemption") {
       inviteClaimCalls += 1;
       if (inviteClaimGate) await inviteClaimGate;
       return { ok: true, updated: true, mirrored: true };
     }
+    // The gateway owns the ACL verdict; activation fails closed when the relay
+    // does not land, so model a verified upsert for the redemption paths.
+    if (method === "upsert_verified_channel") {
+      return {
+        ok: true,
+        verified: true,
+        channel: {
+          id: "gw-channel-id",
+          contactId: (params?.contactId as string) ?? "gw-contact",
+          type: (params?.type as string) ?? "phone",
+          address: (params?.address as string) ?? "gw-addr",
+          status: "active",
+          verifiedAt: 1,
+          verifiedVia: (params?.verifiedVia as string) ?? "invite",
+        },
+      };
+    }
     return undefined;
   },
 }));
@@ -97,7 +119,12 @@ mock.module("../prompts/user-reference.js", () => ({
 // the DB-seeded createGuardianBinding setup. Single mock registration lives
 // below since `mock.module` is process-global and last-write-wins in Bun.
 let mockGuardianDeliveryList:
-  | Array<{ channelType: string; status: string; displayName: string | null }>
+  | Array<{
+      channelType: string;
+      status: string;
+      displayName?: string | null;
+      address?: string;
+    }>
   | null = null;
 
 // ── Config mock ─────────────────────────────────────────────────────
@@ -224,28 +251,54 @@ mock.module("../calls/inbound-trust-reader.js", () => ({
 //
 // Guardian identity now resolves via the gateway delivery reader. Derive the
 // list from the DB-seeded guardian bindings so the existing createGuardianBinding
-// setup keeps driving guardian resolution without per-test changes.
-const realContactStoreModule = {
-  ...(await import("../contacts/contact-store.js")),
-};
-mock.module("../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => {
-    // Tests that set mockGuardianDeliveryList drive the binding directly;
-    // otherwise derive from the DB-seeded createGuardianBinding bindings.
-    if (mockGuardianDeliveryList) return mockGuardianDeliveryList;
-    const guardians = realContactStoreModule.listGuardianChannels();
-    if (!guardians) return [];
-    return guardians.channels.map((ch) => ({
-      channelType: ch.type,
-      contactId: guardians.contact.id,
-      principalId: guardians.contact.principalId ?? null,
-      displayName: guardians.contact.displayName ?? null,
-      address: ch.address,
-      externalChatId: ch.externalChatId ?? null,
-      status: ch.status,
-      verifiedAt: ch.verifiedAt ?? null,
+// setup keeps driving guardian resolution without per-test changes. Both the
+// async read and the sync cache peek (read by resolveActorTrust) share the same
+// DB-derived snapshot mirroring the gateway's active-guardian-channel query.
+function deriveGuardianDeliveries(
+  channelTypes?: string[],
+): Array<Record<string, unknown>> {
+  if (mockGuardianDeliveryList) {
+    return channelTypes
+      ? mockGuardianDeliveryList.filter((g) =>
+          channelTypes.includes(g.channelType as string),
+        )
+      : mockGuardianDeliveryList;
+  }
+  const rows = getDb()
+    .select({ contact: contacts, channel: contactChannels })
+    .from(contacts)
+    .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
+    .where(
+      and(eq(contacts.role, "guardian"), eq(contactChannels.status, "active")),
+    )
+    .orderBy(desc(contactChannels.verifiedAt))
+    .all();
+  if (rows.length === 0) return [];
+  const guardianId = rows[0].contact.id;
+  const list = rows
+    .filter((r) => r.contact.id === guardianId)
+    .map((r) => ({
+      channelType: r.channel.type,
+      contactId: r.contact.id,
+      principalId: r.contact.principalId ?? null,
+      displayName: r.contact.displayName ?? null,
+      address: r.channel.address,
+      externalChatId: r.channel.externalChatId ?? null,
+      status: r.channel.status,
+      verifiedAt: r.channel.verifiedAt ?? null,
     }));
-  },
+  return channelTypes
+    ? list.filter((g) =>
+        channelTypes.includes(g.channelType),
+      )
+    : list;
+}
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async (input?: { channelTypes?: string[] }) =>
+    deriveGuardianDeliveries(input?.channelTypes),
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) =>
+    deriveGuardianDeliveries(input?.channelTypes),
   guardianForChannel: (
     list: Array<{ channelType: string; status: string }>,
     channelType: string,
@@ -388,7 +441,6 @@ import {
 } from "../calls/relay-server.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
 import { upsertContact } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import {
   listCanonicalGuardianRequests,
   resolveCanonicalGuardianRequest,
@@ -402,7 +454,11 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { createInvite } from "../memory/invite-store.js";
 import { resetTestTables } from "../memory/raw-query.js";
-import { conversations } from "../memory/schema.js";
+import {
+  contactChannels,
+  contacts,
+  conversations,
+} from "../memory/schema.js";
 import {
   createOutboundSession,
   getGuardianBinding,
@@ -410,6 +466,7 @@ import {
 import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
+import { seedContactChannel } from "./helpers/seed-contact-channel.js";
 
 await initializeDb();
 
@@ -500,7 +557,7 @@ function createTargetContact(displayName = "Test Contact"): string {
 }
 
 function addTrustedVoiceContact(phoneNumber: string): void {
-  upsertContactChannel({
+  seedContactChannel({
     sourceChannel: "phone",
     externalUserId: phoneNumber,
     externalChatId: phoneNumber,
@@ -2811,7 +2868,7 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "phone",
       externalUserId: "+15558886666",
       externalChatId: "+15558886666",
@@ -2874,7 +2931,7 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "phone",
       externalUserId: "+15558887777",
       externalChatId: "+15558887777",
@@ -3173,7 +3230,7 @@ describe("relay-server", () => {
     });
 
     // Create a blocked member
-    upsertContactChannel({
+    seedContactChannel({
       sourceChannel: "phone",
       externalUserId: "+15558881111",
       externalChatId: "+15558881111",
@@ -5071,7 +5128,7 @@ describe("relay-server", () => {
 
     // Gateway binding carries a different displayName
     mockGuardianDeliveryList = [
-      { channelType: "phone", status: "active", displayName: "Bob" },
+      { channelType: "phone", status: "active", address: "+15550000001", displayName: "Bob" },
     ];
 
     ensureConversation("conv-label-user-md");
@@ -5111,7 +5168,7 @@ describe("relay-server", () => {
 
     // Gateway binding carries the guardian displayName
     mockGuardianDeliveryList = [
-      { channelType: "phone", status: "active", displayName: "Charlie" },
+      { channelType: "phone", status: "active", address: "+15550000002", displayName: "Charlie" },
     ];
 
     ensureConversation("conv-label-contact");

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -44,7 +44,6 @@ mock.module("../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => undefined,
 }));
 
-import { upsertContact } from "../contacts/contact-store.js";
 import {
   linkAttachmentToMessage,
   uploadAttachment,
@@ -58,7 +57,10 @@ import { resetTestTables } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
-import { resolveLocalTrustVerdict } from "./helpers/channel-test-adapter.js";
+import {
+  resolveLocalTrustVerdict,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 
 await initializeDb();
 
@@ -251,16 +253,12 @@ describe("WhatsApp channel ingress attachment resolution", () => {
   }
 
   function ensureWhatsAppContact(): void {
-    upsertContact({
+    seedContactChannel({
+      sourceChannel: "whatsapp",
+      externalUserId: WHATSAPP_USER_ID,
       displayName: "WhatsApp Test User",
-      channels: [
-        {
-          type: "whatsapp",
-          address: WHATSAPP_USER_ID,
-          status: "active",
-          policy: "allow",
-        },
-      ],
+      status: "active",
+      policy: "allow",
     });
   }
 

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

@@ -17,6 +17,34 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// Guardian identity resolves via the gateway delivery cache, not the local
+// contacts DB. Seed it per-test via seedGatewayGuardian; persona resolution
+// joins the local contact (userFile) by the delivery's channelType + address.
+interface GatewayGuardian {
+  channelType: string;
+  address: string;
+  status: string;
+}
+let gatewayGuardians: GatewayGuardian[] = [];
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) => {
+    if (!input?.channelTypes) return gatewayGuardians;
+    return gatewayGuardians.filter((g) =>
+      input.channelTypes!.includes(g.channelType),
+    );
+  },
+  guardianForChannel: (list: GatewayGuardian[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: GatewayGuardian[]) => list[0],
+}));
+
+function seedGatewayGuardian(g: {
+  channelType: string;
+  address: string;
+}): void {
+  gatewayGuardians.push({ status: "active", ...g });
+}
+
 import { getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
@@ -32,6 +60,7 @@ function resetContactTables(): void {
   const sqlite = getSqlite();
   sqlite.run("DELETE FROM contact_channels");
   sqlite.run("DELETE FROM contacts");
+  gatewayGuardians = [];
 }
 
 // ---------------------------------------------------------------------------
@@ -76,6 +105,7 @@ describe("GET /workspace-files", () => {
   });
 
   test("with a guardian: includes users/<slug>.md", async () => {
+    seedGatewayGuardian({ channelType: "telegram", address: "Alice" });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "Alice",
@@ -103,6 +133,7 @@ describe("GET /workspace-files", () => {
     };
     expect(result.files.map((f) => f.path)).not.toContain("users/alice.md");
 
+    seedGatewayGuardian({ channelType: "telegram", address: "Alice" });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "Alice",
@@ -130,6 +161,7 @@ describe("GET /workspace-files/read", () => {
   });
 
   test("reads a guardian users/<slug>.md file", async () => {
+    seedGatewayGuardian({ channelType: "telegram", address: "Alice" });
     createGuardianBinding({
       channel: "telegram",
       guardianExternalUserId: "Alice",

package/src/__tests__/slack-block-formatting.test.ts

@@ -1,9 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  isSlackCallbackUrl,
-  textToSlackBlocks,
-} from "../runtime/slack-block-formatting.js";
+import { textToSlackBlocks } from "../runtime/slack-block-formatting.js";
 
 describe("textToSlackBlocks", () => {
   test("returns undefined for empty text", () => {
@@ -174,37 +171,3 @@ describe("textToSlackBlocks", () => {
     expect(section.text.text).toContain("|");
   });
 });
-
-describe("isSlackCallbackUrl", () => {
-  test("returns true for Slack deliver URLs", () => {
-    expect(
-      isSlackCallbackUrl(
-        "http://127.0.0.1:7830/deliver/slack?threadTs=123&channel=C456",
-      ),
-    ).toBe(true);
-  });
-
-  test("returns true for bare Slack deliver path", () => {
-    expect(isSlackCallbackUrl("http://localhost:7830/deliver/slack")).toBe(
-      true,
-    );
-  });
-
-  test("returns false for non-Slack URLs", () => {
-    expect(isSlackCallbackUrl("http://localhost:7830/deliver/telegram")).toBe(
-      false,
-    );
-  });
-
-  test("returns false for invalid URLs", () => {
-    expect(isSlackCallbackUrl("not-a-url")).toBe(false);
-  });
-
-  test("returns false for managed outbound URLs", () => {
-    expect(
-      isSlackCallbackUrl(
-        "http://localhost:7830/v1/internal/managed-gateway/outbound-send/?route_id=r1&assistant_id=a1&source_channel=phone",
-      ),
-    ).toBe(false);
-  });
-});