@open-mercato/core 0.6.8-develop.7051.1.2e20648fd5 → 0.6.8-develop.7056.1.1a563a270d

package/src/modules/communication_channels/api/post/test-seed/route.ts

@@ -20,10 +20,16 @@ import {
 } from '../../../commands/connect-credential-channel'
 import { emitCommunicationChannelsEvent } from '../../../events'
 import {
+  TEST_SEED_CHAT_PROVIDER_KEY,
   TEST_SEED_PROVIDER_KEY,
   ensureTestSeedAdapterRegistered,
   isTestChannelSeedingEnabled,
 } from '../../../lib/test-seed'
+import {
+  COMMUNICATION_CHANNELS_INGEST_INBOUND_COMMAND_ID,
+  type IngestInboundMessageInput,
+  type IngestInboundMessageResult,
+} from '../../../commands/ingest-inbound-message'
 
 /**
  * TEST-ONLY channel seeding endpoint.
@@ -32,15 +38,22 @@ import {
  * production default) every request returns 404, so this route is invisible and
  * inert in production. See `lib/test-seed.ts` for the full rationale.
  *
- * Two actions, both scoped to the caller's tenant/org:
- *   - `connect-channel`: connect a network-free `__test_seed__` channel owned by
- *     the caller (delegates to the real connect-credential command so the channel
- *     persists credentials + lands in `status='connected'`). Enables the outbound
- *     compose → deliver → `.sent` chain to complete in CI.
+ * Three actions, all scoped to the caller's tenant/org:
+ *   - `connect-channel`: connect a network-free stub channel owned by the caller
+ *     (delegates to the real connect-credential command so the channel persists
+ *     credentials + lands in `status='connected'`). Enables the outbound
+ *     compose → deliver → `.sent` chain to complete in CI. `providerFlavor: 'chat'`
+ *     connects the non-email stub instead, for tests about sender identity.
+ *   - `ingest-inbound`: run the REAL `ingest_inbound_message` command over an
+ *     adapter-normalized chat frame, so the platform compose path — and every
+ *     validation rule on it — actually executes. Use this for anything that
+ *     claims inbound works.
  *   - `emit-inbound`: insert an inbound `MessageChannelLink` (+ a `messages.message`
  *     row for threading) and emit `communication_channels.message.received` so the
  *     customers link-channel-message subscriber runs against real Postgres. Enables
- *     the inbound auto-link tests (TC-CRM-EMAIL-002..005).
+ *     the inbound auto-link tests (TC-CRM-EMAIL-002..005). NOTE: this action
+ *     deliberately bypasses `messages.messages.compose` — it can never prove that
+ *     the hub accepts a message, only that downstream subscribers fire.
  */
 type RbacServiceLike = {
   loadAcl: (
@@ -68,6 +81,35 @@ const connectChannelSchema = z.object({
   action: z.literal('connect-channel'),
   displayName: z.string().min(1).max(255).optional(),
   externalIdentifier: z.string().min(1).max(255).optional(),
+  /**
+   * Which stub provider to connect. `email` (default) keeps the historical
+   * email-shaped channel; `chat` connects a channel whose senders have no
+   * address, so a test can exercise the hub's non-email identity contract
+   * without inventing one (#4975).
+   */
+  providerFlavor: z.enum(['email', 'chat']).optional(),
+})
+
+/**
+ * Drive the REAL `ingest_inbound_message` command with a chat-shaped frame.
+ *
+ * `emit-inbound` below deliberately bypasses the platform compose path (it
+ * inserts the `messages` row with raw SQL) because it only ever needed a
+ * landing zone for the CRM-link subscribers. That bypass is why an inbound test
+ * could pass while `composeMessageSchema` rejected every real message (#4975).
+ * This action takes the opposite approach: it hands the frame to the adapter and
+ * the ingest command and asserts nothing on the way, so whatever the hub's
+ * contract really is, the test feels it.
+ */
+const ingestInboundSchema = z.object({
+  action: z.literal('ingest-inbound'),
+  channelId: z.string().uuid(),
+  /** Opaque sender handle — a Discord snowflake, a Slack member id, etc. */
+  senderIdentifier: z.string().min(1).max(255),
+  senderDisplayName: z.string().max(255).optional(),
+  body: z.string().max(50_000).optional(),
+  externalMessageId: z.string().min(1).max(255),
+  externalConversationId: z.string().min(1).max(255),
 })
 
 const emitInboundSchema = z.object({
@@ -103,7 +145,11 @@ const emitInboundSchema = z.object({
   createThreadMapping: z.boolean().optional(),
 })
 
-const bodySchema = z.discriminatedUnion('action', [connectChannelSchema, emitInboundSchema])
+const bodySchema = z.discriminatedUnion('action', [
+  connectChannelSchema,
+  ingestInboundSchema,
+  emitInboundSchema,
+])
 
 export async function POST(req: Request): Promise<Response> {
   // Fail-closed: invisible in production. Mirrors an unknown route (404) rather
@@ -139,13 +185,23 @@ export async function POST(req: Request): Promise<Response> {
   if (body.action === 'connect-channel') {
     const stamp = Date.now()
     const commandBus = container.resolve('commandBus') as CommandBus
+    const isChatFlavor = body.providerFlavor === 'chat'
+    // A chat channel is deliberately connected WITHOUT an email-ish credential
+    // key, so `connect-credential-channel` derives no `externalIdentifier` and
+    // the row is shaped exactly like a real Discord channel (identifier NULL —
+    // the condition #4977 describes). Inventing one here would recreate the
+    // fixture dishonesty that hid #4975.
+    const credentials = isChatFlavor
+      ? { handle: body.externalIdentifier ?? `test-seed-chat-${stamp}` }
+      : {
+          username: body.externalIdentifier ?? `test-seed-${stamp}@test-seed.local`,
+          fromAddress: body.externalIdentifier ?? `test-seed-${stamp}@test-seed.local`,
+        }
     const input: ConnectCredentialChannelInput = {
-      providerKey: TEST_SEED_PROVIDER_KEY,
-      displayName: body.displayName ?? `Test Seed Channel ${stamp}`,
-      credentials: {
-        username: body.externalIdentifier ?? `test-seed-${stamp}@test-seed.local`,
-        fromAddress: body.externalIdentifier ?? `test-seed-${stamp}@test-seed.local`,
-      },
+      providerKey: isChatFlavor ? TEST_SEED_CHAT_PROVIDER_KEY : TEST_SEED_PROVIDER_KEY,
+      displayName:
+        body.displayName ?? `Test Seed ${isChatFlavor ? 'Chat ' : ''}Channel ${stamp}`,
+      credentials,
       userId,
       scope: { tenantId, organizationId },
     }
@@ -174,9 +230,12 @@ export async function POST(req: Request): Promise<Response> {
     )
   }
 
-  // action === 'emit-inbound'
+  // action === 'ingest-inbound' | 'emit-inbound' — both address an existing channel.
   const em = (container.resolve('em') as EntityManager).fork()
-  const providerKey = body.providerKey ?? TEST_SEED_PROVIDER_KEY
+  // Only the `emit-inbound` branch stamps a caller-chosen provider key onto the
+  // rows it seeds; `ingest-inbound` takes the channel's own (see below).
+  const providerKey =
+    body.action === 'emit-inbound' ? body.providerKey ?? TEST_SEED_PROVIDER_KEY : TEST_SEED_PROVIDER_KEY
 
   // `channelId` is caller-supplied, so confirm it names a channel this tenant/org
   // actually owns before seeding rows that reference it. Mirrors the ownership
@@ -227,6 +286,85 @@ export async function POST(req: Request): Promise<Response> {
     )
   }
 
+  if (body.action === 'ingest-inbound') {
+    // Everything below this point is the real path: the adapter normalizes the
+    // frame and `ingest_inbound_message` composes the platform message through
+    // `messages.messages.compose`. Nothing is short-circuited, so a hub contract
+    // the provider cannot satisfy surfaces here as a failure instead of hiding
+    // behind seeded rows (#4975).
+    // The channel's own provider key, never a hardcoded one: ingest does not
+    // check that `providerKey` matches the channel it names, so passing a
+    // different one would silently stamp the wrong provider onto the link.
+    const channelProviderKey = ownedChannel.providerKey
+    if (channelProviderKey !== TEST_SEED_CHAT_PROVIDER_KEY) {
+      return NextResponse.json(
+        {
+          error:
+            'ingest-inbound requires a channel connected with providerFlavor: "chat"; ' +
+            `channel ${body.channelId} is '${channelProviderKey}'`,
+        },
+        { status: 422 },
+      )
+    }
+
+    const commandBus = container.resolve('commandBus') as CommandBus
+    const adapterRegistry = container.resolve('channelAdapterRegistry') as {
+      get: (key: string) => { normalizeInbound: (raw: unknown) => Promise<unknown> } | undefined
+    }
+    const adapter = adapterRegistry.get(channelProviderKey)
+    if (!adapter) {
+      return NextResponse.json(
+        { error: '[internal] test-seed chat adapter is not registered' },
+        { status: 500 },
+      )
+    }
+
+    const normalized = await adapter.normalizeInbound({
+      raw: {
+        externalMessageId: body.externalMessageId,
+        externalConversationId: body.externalConversationId,
+        senderIdentifier: body.senderIdentifier,
+        senderDisplayName: body.senderDisplayName,
+        body: body.body ?? '',
+      },
+      eventType: 'message',
+      metadata: {},
+    })
+
+    const ingestInput = {
+      channelId: body.channelId,
+      providerKey: channelProviderKey,
+      channelType: ownedChannel.channelType,
+      scope: { tenantId, organizationId },
+      message: normalized,
+    } as IngestInboundMessageInput
+
+    const { result } = await commandBus.execute<
+      IngestInboundMessageInput,
+      IngestInboundMessageResult
+    >(COMMUNICATION_CHANNELS_INGEST_INBOUND_COMMAND_ID, {
+      input: ingestInput,
+      ctx: {
+        container,
+        auth: auth as never,
+        organizationScope: null,
+        selectedOrganizationId: organizationId,
+        organizationIds: organizationId ? [organizationId] : null,
+      },
+    })
+
+    return NextResponse.json(
+      {
+        status: result.status,
+        messageId: result.messageId ?? null,
+        conversationId: result.externalConversationId ?? null,
+        channelLinkId: result.channelLinkId ?? null,
+        channelType: ownedChannel.channelType,
+      },
+      { status: 201 },
+    )
+  }
+
   // A MessageChannelLink requires a non-null external_conversation_id (FK) and
   // message_id. Create a synthetic conversation + (optionally threaded) message
   // so the link is shaped like a real inbound row the subscriber can consume.
@@ -341,7 +479,8 @@ export const openApi = {
   tags: ['CommunicationChannels'],
   methods: {
     POST: {
-      summary: 'Test-only: seed a connected channel or emit an inbound message (env-gated)',
+      summary:
+        'Test-only: seed a connected channel, ingest a real inbound message, or emit a seeded inbound link (env-gated)',
       tags: ['CommunicationChannels'],
       responses: [
         { status: 201, description: 'Channel seeded / inbound message emitted' },

package/src/modules/communication_channels/commands/ingest-inbound-message.ts

@@ -385,6 +385,11 @@ const ingestInboundMessageCommand: CommandHandler<IngestInboundMessageInput, Ing
       sourceEntityId: conversation.id,
       externalEmail: contactHint?.email ?? undefined,
       externalName: contactHint?.displayName ?? m.senderDisplayName,
+      // #4975: tells the hub which identity contract applies to this sender.
+      // Email-typed channels keep the mandatory `externalEmail`; providers whose
+      // senders have no address (Discord, Slack, SMS…) are validated without it.
+      // The messages validator fails closed on any type it does not recognize.
+      sourceChannelType: input.channelType,
       recipients: mapping?.assignedUserId
         ? [{ userId: mapping.assignedUserId, type: 'to' as const }]
         : [],

package/src/modules/communication_channels/di.ts

@@ -11,6 +11,7 @@ import {
 import { getChannelAdapterRegistry } from './lib/adapter-registry-singleton'
 import { ensureTestSeedAdapterRegistered } from './lib/test-seed'
 import { sendAsUser } from './lib/send-as-user'
+import { resolveChannelTypeSafely } from './lib/resolve-channel-type'
 
 export function register(container: AppContainer) {
   // Test-only: register the network-free stub channel adapter when
@@ -36,5 +37,11 @@ export function register(container: AppContainer) {
     // In-process send-as-user facade. Cross-module callers (e.g. the customers
     // compose route) resolve this instead of making an HTTP self-call.
     communicationChannelsSendAsUser: asValue(sendAsUser),
+
+    // Cross-module channel-type lookup. The messages compose route resolves this
+    // to decide whether an external correspondent must carry an email address
+    // (#4975); absent module or failed lookup reads as "unknown", which the
+    // messages validator handles fail-closed.
+    communicationChannelsResolveChannelType: asValue(resolveChannelTypeSafely),
   })
 }

package/src/modules/communication_channels/lib/adapter.ts

@@ -48,6 +48,20 @@ export interface ChannelCapabilities {
    * Optional; existing chat providers (Slack, WhatsApp) omit and are treated as `true`.
    */
   realtimePush?: boolean
+
+  /**
+   * Shape of the outbound recipient this provider's `sendMessage` accepts as
+   * `metadata.to`. Optional; when absent the hub validates recipients as email
+   * addresses, so every provider that predates this field keeps its exact
+   * behavior.
+   *
+   * Declare `'provider-native'` when recipients are provider-issued identifiers
+   * rather than email addresses (e.g. a Discord channel snowflake). The hub then
+   * applies transport-safety checks only (see `validateOutboundRecipient`) and
+   * the adapter owns the provider-specific format — it MUST treat the value as
+   * untrusted input.
+   */
+  recipientFormat?: 'email' | 'provider-native'
 }
 
 // ── Send / status / sender listing ────────────────────────────

package/src/modules/communication_channels/lib/email-capabilities.ts

@@ -57,4 +57,8 @@ export const baseEmailCapabilities: ChannelCapabilities = {
 
   // Polling (real-time push deferred to v2 for all email providers)
   realtimePush: false,
+
+  // Stated rather than left to the default so the email baseline reads as an
+  // explicit choice: outbound recipients here are addresses, not provider ids.
+  recipientFormat: 'email',
 }

package/src/modules/communication_channels/lib/outbound-recipient.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+import type { ChannelCapabilities } from './adapter'
+
+/**
+ * Upper bound shared by both recipient shapes. 320 is the RFC 5321 maximum for
+ * an email address (64 local + `@` + 255 domain); provider-native identifiers
+ * are far shorter, so one ceiling covers both.
+ */
+export const MAX_OUTBOUND_RECIPIENT_LENGTH = 320
+
+const emailRecipientSchema = z.string().email()
+
+/**
+ * Characters a provider-native recipient may contain. This is an allowlist, not a
+ * denylist, because the recipient reaches adapters that interpolate it into a REST
+ * path (Discord posts to `/channels/{recipient}/messages`), and a denylist fails
+ * open on every character nobody thought of — percent-encoded separators
+ * (`%2F`, `%2e%2e%2f`) and control bytes (NUL, DEL) all walked through the
+ * previous `[\r\n\s/\\?#]` class. An allowlist fails closed instead: the worst
+ * case is a provider whose identifier alphabet needs widening, which is a
+ * reviewable one-line change rather than a silent path-steering primitive.
+ *
+ * The set covers every provider-native identifier shape the hub has to carry
+ * today — Discord snowflakes (digits), Slack-style ids (alphanumerics), and email
+ * addresses, since `'provider-native'` must never narrow what `'email'` accepts.
+ */
+const PROVIDER_NATIVE_ALLOWED = /^[A-Za-z0-9._:@+-]+$/
+
+export type OutboundRecipientCheck = { ok: true } | { ok: false; error: string }
+
+/**
+ * Validate an outbound recipient against the provider's declared recipient
+ * shape.
+ *
+ * The hub used to hard-wire `z.string().email()` on every outbound endpoint,
+ * which left providers whose recipients are not email addresses with no product
+ * path to send at all (#4976). Validation now follows the adapter's
+ * `capabilities.recipientFormat`, defaulting to `'email'` so every existing
+ * provider keeps byte-identical behavior.
+ */
+export function validateOutboundRecipient(
+  recipient: unknown,
+  capabilities: Pick<ChannelCapabilities, 'recipientFormat'> | null | undefined,
+): OutboundRecipientCheck {
+  if (typeof recipient !== 'string' || recipient.length === 0) {
+    return { ok: false, error: 'Recipient is required' }
+  }
+  if (recipient.length > MAX_OUTBOUND_RECIPIENT_LENGTH) {
+    return {
+      ok: false,
+      error: `Recipient must be at most ${MAX_OUTBOUND_RECIPIENT_LENGTH} characters`,
+    }
+  }
+  if (capabilities?.recipientFormat !== 'provider-native') {
+    return emailRecipientSchema.safeParse(recipient).success
+      ? { ok: true }
+      : { ok: false, error: 'Recipient must be a valid email address' }
+  }
+  if (!PROVIDER_NATIVE_ALLOWED.test(recipient)) {
+    return {
+      ok: false,
+      error: 'Recipient may only contain letters, digits, and the characters . _ : @ + -',
+    }
+  }
+  // `.` is allowed (email addresses need it), so traversal still has to be
+  // rejected explicitly even though the separators it would need are not.
+  if (recipient.includes('..')) {
+    return { ok: false, error: 'Recipient must not contain ".."' }
+  }
+  return { ok: true }
+}

package/src/modules/communication_channels/lib/resolve-channel-type.ts

@@ -0,0 +1,99 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { CommunicationChannel, ExternalConversation, MessageChannelLink } from '../data/entities'
+
+const logger = createLogger('communication_channels').child({ component: 'resolve-channel-type' })
+
+export type ChannelTypeScope = {
+  tenantId: string
+  organizationId: string | null
+}
+
+export type ChannelTypeReference = {
+  /** `ExternalConversation.id`, as carried by a message's `sourceEntityId`. */
+  externalConversationId?: string | null
+  /** A platform `messages.message` id that may be linked to a channel. */
+  messageId?: string | null
+}
+
+/**
+ * Resolve the channel type behind a platform message or conversation (#4975).
+ *
+ * Cross-module callers (the `messages` compose route) need to know whether an
+ * external correspondent is reachable by email before validating a compose
+ * payload, but `messages` may not reach into this module's entities. They
+ * resolve this facade from DI instead — mirroring `communicationChannelsSendAsUser`
+ * — and treat a `null` result as "unknown", which the messages validator
+ * handles fail-closed.
+ *
+ * Always tenant/organization scoped: a reference that does not resolve inside
+ * the caller's scope is reported as unknown rather than looked up globally.
+ */
+export async function resolveChannelType(
+  container: AppContainer,
+  scope: ChannelTypeScope,
+  reference: ChannelTypeReference,
+): Promise<string | null> {
+  const em = (container.resolve('em') as EntityManager).fork()
+  const dscope = { tenantId: scope.tenantId, organizationId: scope.organizationId ?? null }
+  const baseFilter = { tenantId: scope.tenantId, organizationId: scope.organizationId ?? null }
+
+  let externalConversationId = reference.externalConversationId ?? null
+
+  if (!externalConversationId && reference.messageId) {
+    // The message is linked to a channel directly — `MessageChannelLink` carries
+    // a denormalized channel type, so this is the cheapest hop when it exists.
+    const link = await findOneWithDecryption(
+      em,
+      MessageChannelLink,
+      { messageId: reference.messageId, ...baseFilter },
+      undefined,
+      dscope,
+    )
+    if (link?.channelType) return link.channelType
+    externalConversationId = link?.externalConversationId ?? null
+  }
+
+  if (!externalConversationId) return null
+
+  const conversation = await findOneWithDecryption(
+    em,
+    ExternalConversation,
+    { id: externalConversationId, ...baseFilter },
+    undefined,
+    dscope,
+  )
+  if (!conversation?.channelId) return null
+
+  const channel = await findOneWithDecryption(
+    em,
+    CommunicationChannel,
+    { id: conversation.channelId, ...baseFilter, deletedAt: null },
+    undefined,
+    dscope,
+  )
+  return channel?.channelType ?? null
+}
+
+/**
+ * Same contract, but never throws: a lookup failure degrades to "unknown" so a
+ * transient database error cannot turn into a 500 on an otherwise valid compose.
+ * Unknown is the safe answer — the messages validator fails closed on it.
+ */
+export async function resolveChannelTypeSafely(
+  container: AppContainer,
+  scope: ChannelTypeScope,
+  reference: ChannelTypeReference,
+): Promise<string | null> {
+  try {
+    return await resolveChannelType(container, scope, reference)
+  } catch (err) {
+    logger.warn('channel type resolution failed, treating the channel as unknown', { err })
+    return null
+  }
+}
+
+/** DI service type for cross-module callers (resolve `communicationChannelsResolveChannelType`). */
+export type ResolveChannelTypeService = typeof resolveChannelTypeSafely

package/src/modules/communication_channels/lib/test-seed.ts

@@ -41,6 +41,19 @@ import { hasChannelAdapter, registerChannelAdapter } from './adapter-registry-si
 /** Provider key for the network-free test stub adapter. */
 export const TEST_SEED_PROVIDER_KEY = '__test_seed__'
 
+/**
+ * Provider key for the network-free stub adapter that stands in for a CHAT
+ * provider — one whose senders are identified by an opaque handle and have no
+ * email address at all (Discord, Slack, Telegram…).
+ *
+ * It exists because the email-shaped stub above can only ever prove the hub
+ * accepts email-shaped data. That is precisely how CI stayed green while every
+ * real inbound Discord message was rejected (#4975): the fixture invented an
+ * address the provider can never produce. Tests that need to prove the hub's
+ * non-email identity contract MUST drive this provider instead.
+ */
+export const TEST_SEED_CHAT_PROVIDER_KEY = '__test_seed_chat__'
+
 /** Env flag that unlocks test-only channel seeding. Off in production. */
 export const TEST_CHANNEL_SEEDING_ENV = 'OM_ENABLE_TEST_CHANNEL_SEEDING'
 
@@ -72,8 +85,10 @@ const testSeedCapabilities: ChannelCapabilities = {
  * delivery worker reach its success path and emit `communication_channels.message.sent`.
  */
 class TestSeedChannelAdapter implements ChannelAdapter {
-  readonly providerKey = TEST_SEED_PROVIDER_KEY
-  readonly channelType = 'email'
+  // Widened to `string` rather than inferred as a literal so the chat-flavoured
+  // subclass below can override both with its own provider key / channel type.
+  readonly providerKey: string = TEST_SEED_PROVIDER_KEY
+  readonly channelType: string = 'email'
   readonly capabilities = testSeedCapabilities
 
   async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {
@@ -121,13 +136,54 @@ class TestSeedChannelAdapter implements ChannelAdapter {
   }
 }
 
+/**
+ * Chat-flavoured twin of {@link TestSeedChannelAdapter}: same network-free
+ * behaviour, but it declares a non-email `channelType`, so a channel connected
+ * through it is shaped like a real chat channel — including an
+ * `externalIdentifier` of NULL when no email-ish credential key is supplied.
+ */
+class TestSeedChatChannelAdapter extends TestSeedChannelAdapter {
+  readonly providerKey: string = TEST_SEED_CHAT_PROVIDER_KEY
+  readonly channelType: string = 'discord'
+
+  async normalizeInbound(raw: InboundMessage): Promise<NormalizedInboundMessage> {
+    // Unlike the email stub, this one is reachable: the test-seed ingest action
+    // feeds it a chat-shaped frame so the message travels the real ingest path
+    // (and therefore the real compose validation) rather than a SQL shortcut.
+    const frame = (raw.raw ?? {}) as Record<string, unknown>
+    const senderIdentifier = String(frame.senderIdentifier ?? '')
+    if (!senderIdentifier) {
+      throw new Error('[internal] TestSeedChatChannelAdapter requires a senderIdentifier')
+    }
+    return {
+      externalMessageId: String(frame.externalMessageId ?? ''),
+      externalConversationId: String(frame.externalConversationId ?? ''),
+      senderIdentifier,
+      senderDisplayName:
+        typeof frame.senderDisplayName === 'string' ? frame.senderDisplayName : undefined,
+      body: typeof frame.body === 'string' ? frame.body : '',
+      bodyFormat: 'text',
+      timestamp: new Date(),
+      channelPayload: {},
+      channelContentType: 'text/plain',
+      channelMetadata: {},
+    }
+  }
+}
+
 let cachedTestSeedAdapter: TestSeedChannelAdapter | null = null
+let cachedTestSeedChatAdapter: TestSeedChatChannelAdapter | null = null
 
 function getTestSeedChannelAdapter(): TestSeedChannelAdapter {
   if (!cachedTestSeedAdapter) cachedTestSeedAdapter = new TestSeedChannelAdapter()
   return cachedTestSeedAdapter
 }
 
+function getTestSeedChatChannelAdapter(): TestSeedChatChannelAdapter {
+  if (!cachedTestSeedChatAdapter) cachedTestSeedChatAdapter = new TestSeedChatChannelAdapter()
+  return cachedTestSeedChatAdapter
+}
+
 /**
  * Register the test-seed adapter exactly once, but ONLY when the env flag is set.
  * Idempotent and safe to call from every container creation (`di.register`) — a
@@ -135,6 +191,10 @@ function getTestSeedChannelAdapter(): TestSeedChannelAdapter {
  */
 export function ensureTestSeedAdapterRegistered(): void {
   if (!isTestChannelSeedingEnabled()) return
-  if (hasChannelAdapter(TEST_SEED_PROVIDER_KEY)) return
-  registerChannelAdapter(getTestSeedChannelAdapter())
+  if (!hasChannelAdapter(TEST_SEED_PROVIDER_KEY)) {
+    registerChannelAdapter(getTestSeedChannelAdapter())
+  }
+  if (!hasChannelAdapter(TEST_SEED_CHAT_PROVIDER_KEY)) {
+    registerChannelAdapter(getTestSeedChatChannelAdapter())
+  }
 }