@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/runtime/routes/events-routes.ts

@@ -20,9 +20,10 @@
 
 import { type IntervalHistogram, monitorEventLoopDelay } from "node:perf_hooks";
 
+import { sanitizeClientMetadataValue } from "@vellumai/service-contracts/client-metadata";
 import { z } from "zod";
 
-import type { HostProxyCapability } from "../../channels/types.js";
+import type { HostProxyCapability, InterfaceId } from "../../channels/types.js";
 import { parseInterfaceId, supportsHostProxy } from "../../channels/types.js";
 import { notifyContactsChanged } from "../../contacts/notify-contacts-changed.js";
 import { getConversation } from "../../persistence/conversation-crud.js";
@@ -38,7 +39,7 @@ import {
   AssistantEventHub,
   assistantEventHub,
 } from "../assistant-event-hub.js";
-import type { ReplaySubscriber } from "../assistant-stream-state.js";
+import type { SubscriberIdentity } from "../assistant-event-targeting.js";
 import { getReplayWindow } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS, GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
 import { DEFAULT_HEARTBEAT_INTERVAL_MS } from "../client-health.js";
@@ -248,12 +249,14 @@ const defaultSseShedReporter: SseShedReporter = (reason, inst) => {
  *   conversations for this assistant.
  *
  * Headers (optional):
- *   X-Vellum-Client-Id    -- stable per-install UUID identifying this client.
- *   X-Vellum-Interface-Id -- interface type (e.g. "macos", "ios", "web").
+ *   X-Vellum-Client-Id      -- stable per-install UUID identifying this client.
+ *   X-Vellum-Interface-Id   -- interface type (e.g. "macos", "ios", "web").
+ *   X-Vellum-Client-Version -- optional build/manifest version fingerprint.
+ *   X-Vellum-Sse-Watchdog   -- optional "1" when the client has an SSE idle watchdog.
  *
- *   When both are present, the subscriber is registered as a client in the
- *   event hub with metadata (interfaceId, capabilities). The hub handles
- *   lifecycle — dispose() unregisters the client automatically.
+ *   When both identity headers are present, the subscriber is registered as a
+ *   client in the event hub with metadata (interfaceId, capabilities). The hub
+ *   handles lifecycle. dispose() unregisters the client automatically.
  *
  * Options (for testing):
  *   hub               -- override the event hub (defaults to process singleton).
@@ -300,25 +303,18 @@ export function handleSubscribeAssistantEvents(
   }
 
   // ── Client identity from headers ──────────────────────────────────────
-  const rawClientId = headers?.["x-vellum-client-id"];
-  const rawInterfaceId = headers?.["x-vellum-interface-id"];
   const rawMachineName = headers?.["x-vellum-machine-name"];
   const rawActorPrincipalId = headers?.["x-vellum-actor-principal-id"];
-  const clientId = rawClientId?.trim() || null;
-  const interfaceId = clientId
-    ? parseInterfaceId(rawInterfaceId?.trim())
-    : null;
-  // Verified by RuntimeHttpServer and forwarded by the http-adapter from the
-  // bearer token's AuthContext. May be absent for legacy / service-token
-  // connections that have no principal. See `resolveActorPrincipalId` for the
-  // dev-bypass translation rationale.
-  const actorPrincipalId = resolveActorPrincipalIdForLocalGuardianSync(
-    rawActorPrincipalId?.trim() || undefined,
+  const { clientId, interfaceId, actorPrincipalId } =
+    readClientIdentity(headers);
+  const clientVersion = sanitizeClientMetadataValue(
+    headers?.["x-vellum-client-version"],
   );
+  const sseWatchdog = headers?.["x-vellum-sse-watchdog"]?.trim() === "1";
 
   if (clientId && !interfaceId) {
     log.error(
-      { clientId, rawInterfaceId },
+      { clientId, rawInterfaceId: headers?.["x-vellum-interface-id"] },
       "client registration failed: invalid or missing X-Vellum-Interface-Id",
     );
     throw new BadRequestError(
@@ -410,7 +406,7 @@ export function handleSubscribeAssistantEvents(
     try {
       if (controller.desiredSize != null && controller.desiredSize <= 0) {
         shedReporter("callback_backpressure", instrumentation);
-        sub.dispose();
+        sub.dispose("shed_backpressure");
         cleanup();
         return;
       }
@@ -455,6 +451,8 @@ export function handleSubscribeAssistantEvents(
             ],
             machineName: rawMachineName?.trim() || undefined,
             actorPrincipalId,
+            clientVersion,
+            sseWatchdog: sseWatchdog || undefined,
           })
         : hub.subscribe({
             ...subscriberBase,
@@ -521,20 +519,9 @@ export function handleSubscribeAssistantEvents(
         // The client detects the gap from the seq jump on its first
         // live event and refetches via the existing messages API.
         if (lastSeenSeq != null) {
-          const replaySubscriber: ReplaySubscriber =
-            clientId && interfaceId
-              ? {
-                  type: "client",
-                  clientId,
-                  interfaceId,
-                  capabilities: ALL_CAPABILITIES.filter((cap) =>
-                    supportsHostProxy(interfaceId, cap),
-                  ),
-                }
-              : { type: "process" };
           const window = getReplayWindow(
             lastSeenSeq,
-            replaySubscriber,
+            replaySubscriberFor(clientId, interfaceId, actorPrincipalId),
             filter.conversationId,
           );
           if (window !== null) {
@@ -555,7 +542,7 @@ export function handleSubscribeAssistantEvents(
           try {
             if (controller.desiredSize != null && controller.desiredSize <= 0) {
               shedReporter("heartbeat_backpressure", instrumentation);
-              sub.dispose();
+              sub.dispose("shed_backpressure");
               cleanup();
               return;
             }
@@ -590,6 +577,53 @@ export function handleSubscribeAssistantEvents(
   return stream;
 }
 
+/**
+ * The caller's client identity, read the same way by the SSE subscribe route
+ * and the tail route. The principal is verified by RuntimeHttpServer and
+ * forwarded by the http-adapter from the bearer token's AuthContext; it is
+ * absent for legacy and service-token connections, and a dev-bypass header
+ * resolves to the local guardian (see `resolveActorPrincipalIdForLocalGuardianSync`).
+ */
+function readClientIdentity(headers: Record<string, string> | undefined): {
+  clientId: string | null;
+  interfaceId: InterfaceId | null;
+  actorPrincipalId: string | undefined;
+} {
+  const clientId = headers?.["x-vellum-client-id"]?.trim() || null;
+  const interfaceId = clientId
+    ? parseInterfaceId(headers?.["x-vellum-interface-id"]?.trim())
+    : null;
+  const actorPrincipalId = resolveActorPrincipalIdForLocalGuardianSync(
+    headers?.["x-vellum-actor-principal-id"]?.trim() || undefined,
+  );
+  return { clientId, interfaceId, actorPrincipalId };
+}
+
+/**
+ * The identity a replay filter checks targeted events against: the client a
+ * live SSE subscription with these headers would register, or a process
+ * subscriber when the caller names no client. Shared by the reconnect replay
+ * and the tail route so both deliver exactly what live fanout would have.
+ */
+function replaySubscriberFor(
+  clientId: string | null,
+  interfaceId: InterfaceId | null,
+  actorPrincipalId: string | undefined,
+): SubscriberIdentity {
+  if (!clientId || !interfaceId) {
+    return { type: "process" };
+  }
+  return {
+    type: "client",
+    clientId,
+    interfaceId,
+    capabilities: ALL_CAPABILITIES.filter((cap) =>
+      supportsHostProxy(interfaceId, cap),
+    ),
+    actorPrincipalId,
+  };
+}
+
 /**
  * Replay-by-request companion to the SSE `lastSeenSeq` resume: return the
  * ring-buffered event tail for one conversation with `seq > fromSeq`.
@@ -641,26 +675,13 @@ function handleEventsTail({
     toSeq = parsed;
   }
 
-  // Same client-identity resolution as the SSE subscribe handler, so the
-  // replay filter matches what a live subscription would have delivered.
-  const rawClientId = headers?.["x-vellum-client-id"];
-  const clientId = rawClientId?.trim() || null;
-  const interfaceId = clientId
-    ? parseInterfaceId(headers?.["x-vellum-interface-id"]?.trim())
-    : null;
-  const subscriber: ReplaySubscriber | undefined =
-    clientId && interfaceId
-      ? {
-          type: "client",
-          clientId,
-          interfaceId,
-          capabilities: ALL_CAPABILITIES.filter((cap) =>
-            supportsHostProxy(interfaceId, cap),
-          ),
-        }
-      : undefined;
-
-  const window = getReplayWindow(fromSeq, subscriber, conversationId);
+  const { clientId, interfaceId, actorPrincipalId } =
+    readClientIdentity(headers);
+  const window = getReplayWindow(
+    fromSeq,
+    replaySubscriberFor(clientId, interfaceId, actorPrincipalId),
+    conversationId,
+  );
   if (window === null) {
     return { events: [], complete: false, frontier: null };
   }

package/src/runtime/routes/identity-routes.ts

@@ -228,7 +228,7 @@ function getIdentity() {
 
   const version = APP_VERSION;
 
-  const createdAt = resolveIdentityCreatedAt(identityPath);
+  const createdAt = resolveHatchedAtReadOnly(identityPath);
 
   return {
     name: fields.name ?? "",
@@ -241,10 +241,6 @@ function getIdentity() {
   };
 }
 
-function resolveIdentityCreatedAt(identityPath: string): string | undefined {
-  return resolveHatchedAtReadOnly(identityPath);
-}
-
 // ---------------------------------------------------------------------------
 // Zod schemas for profiler health metadata
 // ---------------------------------------------------------------------------

package/src/runtime/routes/image-generation-routes.ts

@@ -5,10 +5,7 @@ import {
   resolveImageGenCredentials,
   resolveImageGenRouting,
 } from "../../media/image-credentials.js";
-import {
-  describeImageModels,
-  resolveImageModel,
-} from "../../media/image-models.js";
+import { resolveRequestedImageModel } from "../../media/image-models.js";
 import { generateImage, mapImageGenError } from "../../media/image-service.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
@@ -80,18 +77,15 @@ async function handleImageGenerationGenerate(
   const config = getConfig();
   const svc = config.services["image-generation"];
 
-  // Resolve tier aliases (fast, quality, openai) to concrete model IDs via
-  // the registry; reject unknown values with the current catalog so the
-  // error is self-describing rather than a stale enum.
+  // Resolve aliases and OpenRouter slugs against the configured provider.
+  // Built-in providers still list the current catalog on unknown values.
   let resolvedModel = model as string | undefined;
   if (typeof resolvedModel === "string" && resolvedModel) {
-    const entry = resolveImageModel(resolvedModel);
-    if (!entry) {
-      throw new BadRequestError(
-        `Unknown model "${resolvedModel}". Available models and aliases:\n${describeImageModels()}`,
-      );
+    const resolved = resolveRequestedImageModel(resolvedModel, svc.provider);
+    if (resolved.error) {
+      throw new BadRequestError(resolved.error);
     }
-    resolvedModel = entry.id;
+    resolvedModel = resolved.model;
   }
 
   // Backend and managed-ness resolve together; an explicit model override
@@ -154,7 +148,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Generate or edit images using AI",
     description:
-      "Calls the configured image-generation provider (Gemini or OpenAI) to produce one or more images.",
+      "Calls the configured image-generation provider (Gemini, OpenAI, or OpenRouter) to produce one or more images.",
     tags: ["image-generation"],
     requestBody: ImageGenerationRequestSchema,
     responseBody: ImageGenerationResponseSchema,

package/src/runtime/routes/inbound-message-handler.ts

@@ -106,7 +106,10 @@ import { markProcessed } from "../../persistence/delivery-status.js";
 import { upsertBinding } from "../../persistence/external-conversation-store.js";
 import type { ContentBlock } from "../../providers/types.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
-import { canonicalizeInboundIdentity } from "../../util/canonicalize-identity.js";
+import {
+  canonicalizeInboundIdentity,
+  inboundIdentitiesMatch,
+} from "../../util/canonicalize-identity.js";
 import { safeParseRecord } from "../../util/json.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
@@ -126,6 +129,11 @@ import {
   enforceIngressAcl,
 } from "./inbound-stages/acl-enforcement.js";
 import { enforceAdmissionPolicy } from "./inbound-stages/admission-policy.js";
+import {
+  type BackfilledSenderProvenance,
+  type BackfilledSenderProvenanceResolver,
+  createBackfilledSenderProvenanceResolver,
+} from "./inbound-stages/backfill-sender-provenance.js";
 import { processChannelMessageInBackground } from "./inbound-stages/background-dispatch.js";
 import { handleBootstrapIntercept } from "./inbound-stages/bootstrap-intercept.js";
 import { handleEditIntercept } from "./inbound-stages/edit-intercept.js";
@@ -1835,6 +1843,7 @@ async function persistBackfilledSlackMessage(params: {
   message: ProviderMessage;
   account?: string;
   guardianExternalUserId?: string;
+  resolveSenderProvenance: BackfilledSenderProvenanceResolver;
 }): Promise<boolean> {
   const { message } = params;
 
@@ -1872,10 +1881,19 @@ async function persistBackfilledSlackMessage(params: {
     message.metadata,
     "actorTimezoneLabel",
   );
-  const isGuardian = isBackfilledSlackGuardianMessage(
+  const role = (await isBackfilledSlackAssistantMessage(
     message,
-    params.guardianExternalUserId,
-  );
+    params.account,
+  ))
+    ? "assistant"
+    : "user";
+  // The assistant's own posts are replayed as assistant history, not as any
+  // person's words, so only a person's row asks who its sender is.
+  const provenance: BackfilledSenderProvenance =
+    role === "user"
+      ? await params.resolveSenderProvenance(actorExternalUserId)
+      : { provenanceTrustClass: "unknown" };
+  const isGuardian = provenance.provenanceTrustClass === "guardian";
   const slackTranscriptTimestampTimezone =
     resolveSlackTranscriptTimestampTimezone();
   const slackTimezoneFields = buildSlackTimezoneMetadata({
@@ -1899,13 +1917,6 @@ async function persistBackfilledSlackMessage(params: {
     ...(slackFiles.length > 0 ? { slackFiles } : {}),
   };
 
-  const role = (await isBackfilledSlackAssistantMessage(
-    message,
-    params.account,
-  ))
-    ? "assistant"
-    : "user";
-
   const rawText = message.text ?? "";
 
   // `sentAt` is when the message was sent; the row's `createdAt` is when the
@@ -1944,7 +1955,7 @@ async function persistBackfilledSlackMessage(params: {
     metadata: {
       ...envelope,
       ...(sentAt !== undefined ? { sentAt } : {}),
-      provenanceTrustClass: isGuardian ? "guardian" : "unknown",
+      ...provenance,
       provenanceSourceChannel: "slack",
       ...(params.guardianExternalUserId
         ? { provenanceGuardianExternalUserId: params.guardianExternalUserId }
@@ -2063,22 +2074,6 @@ async function buildBackfilledSlackContentBlocks(
   return blocks;
 }
 
-function isBackfilledSlackGuardianMessage(
-  message: ProviderMessage,
-  guardianExternalUserId: string | undefined,
-): boolean {
-  const rawSenderId = message.sender?.id?.trim();
-  if (!rawSenderId || !guardianExternalUserId) {
-    return false;
-  }
-  const normalizedSender =
-    canonicalizeInboundIdentity("slack", rawSenderId) ?? rawSenderId;
-  const normalizedGuardian =
-    canonicalizeInboundIdentity("slack", guardianExternalUserId) ??
-    guardianExternalUserId.trim();
-  return normalizedSender === normalizedGuardian;
-}
-
 const SLACK_ASSISTANT_THREAD_PLACEHOLDER_TEXT = "New Assistant Thread";
 
 async function isSlackAssistantThreadPlaceholder(
@@ -2115,7 +2110,7 @@ async function isBackfilledSlackAssistantMessage(
     return false;
   }
 
-  if (rawSenderId && slackIdentityMatches(rawSenderId, botUserId)) {
+  if (rawSenderId && inboundIdentitiesMatch("slack", rawSenderId, botUserId)) {
     return true;
   }
 
@@ -2131,7 +2126,7 @@ async function isBackfilledSlackAssistantMessage(
     const resolvedBotUserId = await resolveSlackBotUserId(account, rawBotId);
     return (
       typeof resolvedBotUserId === "string" &&
-      slackIdentityMatches(resolvedBotUserId, botUserId)
+      inboundIdentitiesMatch("slack", resolvedBotUserId, botUserId)
     );
   } catch (err) {
     log.warn(
@@ -2142,14 +2137,6 @@ async function isBackfilledSlackAssistantMessage(
   }
 }
 
-function slackIdentityMatches(left: string, right: string): boolean {
-  const canonicalSender =
-    canonicalizeInboundIdentity("slack", left) ?? left.trim();
-  const canonicalBot =
-    canonicalizeInboundIdentity("slack", right) ?? right.trim();
-  return canonicalSender === canonicalBot;
-}
-
 /**
  * Transient view of `slackFiles` that preserves the download URLs added by
  * `mapSlackFiles` on the in-flight `ProviderMessage`. These URLs never reach
@@ -2290,6 +2277,10 @@ async function runBackfillSlackDmIfCold(params: {
     // and a transcript that reads correctly when the renderer joins on
     // monotonic createdAt.
     const ordered = [...fetched].reverse();
+    const resolveSenderProvenance = createBackfilledSenderProvenanceResolver(
+      params.guardianExternalUserId,
+      ordered,
+    );
     for (const message of ordered) {
       if (seen.has(message.id)) {
         continue;
@@ -2309,6 +2300,7 @@ async function runBackfillSlackDmIfCold(params: {
           ...(params.guardianExternalUserId
             ? { guardianExternalUserId: params.guardianExternalUserId }
             : {}),
+          resolveSenderProvenance,
         });
         seen.add(message.id);
         if (stored) {
@@ -2890,6 +2882,10 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
     }
 
     let persisted = 0;
+    const resolveSenderProvenance = createBackfilledSenderProvenanceResolver(
+      guardianExternalUserId,
+      fetched,
+    );
     for (const message of fetched) {
       if (!message.id) {
         continue;
@@ -2907,6 +2903,7 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
           message,
           ...(account ? { account } : {}),
           ...(guardianExternalUserId ? { guardianExternalUserId } : {}),
+          resolveSenderProvenance,
         });
         threadState.storedChannelTs.add(message.id);
         if (stored) {

package/src/runtime/routes/inbound-stages/backfill-sender-provenance.test.ts

@@ -0,0 +1,168 @@
+import { afterAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+import type { InboundTrustReadResult } from "../../../calls/inbound-trust-reader.js";
+import * as inboundTrustReader from "../../../calls/inbound-trust-reader.js";
+import type { Message as ProviderMessage } from "../../../messaging/provider-types.js";
+import { createBackfilledSenderProvenanceResolver } from "./backfill-sender-provenance.js";
+
+const readsBySender = new Map<string, InboundTrustReadResult>();
+const readInboundTrustMock = spyOn(
+  inboundTrustReader,
+  "readInboundTrust",
+).mockImplementation(
+  async (input) =>
+    readsBySender.get(input.actorExternalId ?? "") ?? { ok: false },
+);
+
+afterAll(() => {
+  readInboundTrustMock.mockRestore();
+});
+
+const GUARDIAN_ID = "U_GUARDIAN";
+
+function memberVerdict(
+  trustClass: TrustVerdict["trustClass"],
+  contactId: string,
+  status: string,
+): TrustVerdict {
+  return {
+    trustClass,
+    canonicalSenderId: `U_${contactId}`,
+    contactId,
+    channelId: `ch-${contactId}`,
+    status,
+    policy: "allow",
+  };
+}
+
+function readOf(verdict: TrustVerdict): InboundTrustReadResult {
+  return { ok: true, verdict, admissionPolicy: null };
+}
+
+beforeEach(() => {
+  readsBySender.clear();
+  readInboundTrustMock.mockClear();
+});
+
+describe("createBackfilledSenderProvenanceResolver", () => {
+  test("stamps the gateway verdict's trust class and contact id", async () => {
+    readsBySender.set(
+      "U_ALICE",
+      readOf(memberVerdict("trusted_contact", "c-alice", "active")),
+    );
+    readsBySender.set(
+      "U_BOB",
+      readOf(memberVerdict("unverified_contact", "c-bob", "unverified")),
+    );
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    expect(await resolve("U_ALICE")).toEqual({
+      provenanceTrustClass: "trusted_contact",
+      provenanceContactId: "c-alice",
+    });
+    expect(await resolve("U_BOB")).toEqual({
+      provenanceTrustClass: "unverified_contact",
+      provenanceContactId: "c-bob",
+    });
+    expect(readInboundTrustMock).toHaveBeenCalledWith({
+      channelType: "slack",
+      actorExternalId: "U_ALICE",
+    });
+  });
+
+  test("a stranger verdict carries no contact id and no lookup-failed marker", async () => {
+    readsBySender.set(
+      "U_STRANGER",
+      readOf({ trustClass: "unknown", canonicalSenderId: "U_STRANGER" }),
+    );
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    expect(await resolve("U_STRANGER")).toEqual({
+      provenanceTrustClass: "unknown",
+    });
+  });
+
+  test("an unreadable verdict falls back to the guardian address comparison and marks the failed lookup", async () => {
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    expect(await resolve(GUARDIAN_ID)).toEqual({
+      provenanceTrustClass: "guardian",
+      provenanceLookupFailed: true,
+    });
+    expect(await resolve("U_ALICE")).toEqual({
+      provenanceTrustClass: "unknown",
+      provenanceLookupFailed: true,
+    });
+  });
+
+  test("a resolver-failure verdict is not trusted for class or contact id", async () => {
+    readsBySender.set(
+      "U_ALICE",
+      readOf({
+        ...memberVerdict("trusted_contact", "c-alice", "active"),
+        resolutionFailed: true,
+      }),
+    );
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    expect(await resolve("U_ALICE")).toEqual({
+      provenanceTrustClass: "unknown",
+      provenanceLookupFailed: true,
+    });
+  });
+
+  test("reads the gateway once per distinct sender", async () => {
+    readsBySender.set(
+      "U_ALICE",
+      readOf(memberVerdict("trusted_contact", "c-alice", "active")),
+    );
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    await Promise.all([
+      resolve("U_ALICE"),
+      resolve(" U_ALICE "),
+      resolve("U_BOB"),
+    ]);
+    await resolve("U_ALICE");
+
+    expect(readInboundTrustMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("a row with no sender id is unknown without a gateway read or a lookup-failed marker", async () => {
+    const resolve = createBackfilledSenderProvenanceResolver(GUARDIAN_ID, []);
+
+    expect(await resolve(undefined)).toEqual({
+      provenanceTrustClass: "unknown",
+    });
+    expect(readInboundTrustMock).not.toHaveBeenCalled();
+  });
+
+  test("starts every sender's read up front and together, bots included", () => {
+    const message = (id: string, senderId: string, isBot = false) =>
+      ({
+        id,
+        conversationId: "C1",
+        sender: { id: senderId, name: senderId },
+        text: "hi",
+        timestamp: 0,
+        platform: "slack",
+        ...(isBot ? { metadata: { isBot: true } } : {}),
+      }) satisfies ProviderMessage;
+
+    createBackfilledSenderProvenanceResolver(GUARDIAN_ID, [
+      message("1", "U_ALICE"),
+      message("2", "B_THIRD_PARTY", true),
+      message("3", "U_ALICE"),
+      message("4", "U_BOB"),
+    ]);
+
+    // Every read is in flight before any of them has settled.
+    expect(readInboundTrustMock.mock.calls.map(([input]) => input)).toEqual([
+      { channelType: "slack", actorExternalId: "U_ALICE" },
+      { channelType: "slack", actorExternalId: "B_THIRD_PARTY" },
+      { channelType: "slack", actorExternalId: "U_BOB" },
+    ]);
+  });
+});