@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/src/modules/channel_discord/i18n/es.json

@@ -0,0 +1,57 @@
+{
+  "channel_discord.aiAutoReply.errors.agentFeaturesMissing": "El usuario bot del canal no tiene los permisos que necesita este agente: {features}. Concédelos primero o elige otro agente.",
+  "channel_discord.aiAutoReply.errors.agentNotEligible": "Ese agente no puede responder en un canal: elige uno que produzca salida estructurada",
+  "channel_discord.aiAutoReply.errors.agentRequired": "Elige el agente que debe responder en este canal",
+  "channel_discord.aiAutoReply.errors.aiUnavailable": "La respuesta automática necesita el módulo de asistente de IA, que no está instalado en este despliegue",
+  "channel_discord.aiAutoReply.errors.load": "No se pudo cargar la configuración de respuesta automática de IA",
+  "channel_discord.aiAutoReply.errors.loadChannels": "No se pudieron cargar los canales de Discord",
+  "channel_discord.aiAutoReply.errors.save": "No se pudo guardar la configuración de respuesta automática de IA",
+  "channel_discord.aiAutoReply.fields.agent": "Agente",
+  "channel_discord.aiAutoReply.fields.agentHelp": "Solo los agentes que producen salida estructurada pueden responder en un canal. Concede al usuario bot del inquilino los permisos que exige el agente antes de elegir uno de otro módulo.",
+  "channel_discord.aiAutoReply.fields.agentMissingFeatures": "{label}: necesita {features}",
+  "channel_discord.aiAutoReply.fields.enabled": "Responder los mensajes entrantes de Discord con IA",
+  "channel_discord.aiAutoReply.fields.enabledHelp": "Desactivado por defecto. Al activarlo, los mensajes sencillos se responden automáticamente; todo lo delicado, poco fiable o sospechoso se propone para que lo apruebe una persona.",
+  "channel_discord.aiAutoReply.intro": "Decide si este canal de Discord puede responder por su cuenta y qué agente redacta la respuesta.",
+  "channel_discord.aiAutoReply.lastError": "El último intento de respuesta automática en este canal no produjo nada: {reason}",
+  "channel_discord.aiAutoReply.lastErrorAt": "(visto por primera vez el {at})",
+  "channel_discord.aiAutoReply.loading": "Cargando la configuración de respuesta automática de IA...",
+  "channel_discord.aiAutoReply.loadingChannels": "Cargando canales de Discord...",
+  "channel_discord.aiAutoReply.notFound": "Canal de Discord no encontrado",
+  "channel_discord.aiAutoReply.page.title": "Respuesta automática de IA en Discord",
+  "channel_discord.aiAutoReply.save": "Guardar",
+  "channel_discord.aiAutoReply.saved": "Configuración de respuesta automática de IA guardada.",
+  "channel_discord.aiAutoReply.unavailable": "El módulo de asistente de IA no está instalado en este despliegue, así que no se puede activar la respuesta automática. El canal sigue funcionando como una bandeja de entrada normal.",
+  "channel_discord.aiAutoReply.widget.configure": "Configurar",
+  "channel_discord.aiAutoReply.widget.description": "Deja que un agente de IA responda los mensajes entrantes de Discord. Cada canal está desactivado por defecto, y todo lo delicado o poco fiable se propone para que lo apruebe una persona en lugar de enviarse.",
+  "channel_discord.aiAutoReply.widget.failing": "Respuesta automática con fallos",
+  "channel_discord.aiAutoReply.widget.lastError": "El último intento falló: {reason}",
+  "channel_discord.aiAutoReply.widget.noAgent": "Ningún agente seleccionado",
+  "channel_discord.aiAutoReply.widget.noChannels": "Conecta primero un bot de Discord: la respuesta automática se configura por canal.",
+  "channel_discord.aiAutoReply.widget.off": "Respuesta automática desactivada",
+  "channel_discord.aiAutoReply.widget.on": "Respuesta automática activada",
+  "channel_discord.aiAutoReply.widget.title": "Respuesta automática de IA",
+  "channel_discord.aiAutoReply.widget.truncated": "Solo se muestran los canales más recientes. Abre un canal desde la página de canales para configurar el resto.",
+  "channel_discord.aiProposal.actions.approve": "Aprobar y enviar",
+  "channel_discord.aiProposal.actions.dismiss": "Descartar",
+  "channel_discord.aiProposal.messageType": "Respuesta de Discord propuesta",
+  "channel_discord.connect.blocked": "Conexión bloqueada por validación",
+  "channel_discord.connect.button": "Conectar Discord",
+  "channel_discord.connect.cancel": "Cancelar",
+  "channel_discord.connect.connected": "Canal de Discord conectado.",
+  "channel_discord.connect.connecting": "Conectando...",
+  "channel_discord.connect.failed": "No se pudo conectar el bot de Discord.",
+  "channel_discord.connect.fields.applicationId": "ID de aplicación",
+  "channel_discord.connect.fields.botToken": "Token del bot",
+  "channel_discord.connect.fields.defaultChannelId": "ID del canal predeterminado",
+  "channel_discord.connect.fields.displayName": "Nombre para mostrar",
+  "channel_discord.connect.fields.guildId": "ID del servidor (guild)",
+  "channel_discord.connect.fields.publicKey": "Clave pública",
+  "channel_discord.connect.save": "Conectar",
+  "channel_discord.connect.title": "Conectar bot de Discord",
+  "channel_discord.interactions.commandReceived": "Recibido: `/{command}` ya está en la bandeja de entrada de Open Mercato y alguien se encargará desde allí.",
+  "channel_discord.interactions.componentReceived": "Recibido: tu respuesta ya está en la bandeja de entrada de Open Mercato y alguien se encargará desde allí.",
+  "channel_discord.interactions.dispatchFailed": "Open Mercato no ha podido registrar esta interacción ahora mismo. Inténtalo de nuevo en un momento.",
+  "channel_discord.interactions.notDispatchable": "A esta interacción le falta el contexto de canal o de usuario que Open Mercato necesita, así que no se registró.",
+  "channel_discord.interactions.unsupported": "El canal de Discord de Open Mercato no gestiona este tipo de interacción.",
+  "channel_discord.provider.label": "Discord"
+}

package/src/modules/channel_discord/i18n/ko.json

@@ -0,0 +1,57 @@
+{
+  "channel_discord.aiAutoReply.errors.agentFeaturesMissing": "채널 봇 사용자에게 이 에이전트가 필요로 하는 권한이 없습니다: {features}. 먼저 권한을 부여하거나 다른 에이전트를 선택하세요.",
+  "channel_discord.aiAutoReply.errors.agentNotEligible": "해당 에이전트는 채널에서 답장할 수 없습니다 — 구조화된 출력을 생성하는 에이전트를 선택하세요",
+  "channel_discord.aiAutoReply.errors.agentRequired": "이 채널에서 답장할 에이전트를 선택하세요",
+  "channel_discord.aiAutoReply.errors.aiUnavailable": "자동 응답에는 AI 어시스턴트 모듈이 필요하지만 이 배포에는 설치되어 있지 않습니다",
+  "channel_discord.aiAutoReply.errors.load": "AI 자동 응답 설정을 불러오지 못했습니다",
+  "channel_discord.aiAutoReply.errors.loadChannels": "Discord 채널을 불러오지 못했습니다",
+  "channel_discord.aiAutoReply.errors.save": "AI 자동 응답 설정을 저장하지 못했습니다",
+  "channel_discord.aiAutoReply.fields.agent": "에이전트",
+  "channel_discord.aiAutoReply.fields.agentHelp": "구조화된 출력을 생성하는 에이전트만 채널에서 답장할 수 있습니다. 다른 모듈의 에이전트를 선택하기 전에 테넌트의 채널 봇 사용자에게 해당 에이전트가 요구하는 권한을 부여하세요.",
+  "channel_discord.aiAutoReply.fields.agentMissingFeatures": "{label} — {features} 필요",
+  "channel_discord.aiAutoReply.fields.enabled": "수신된 Discord 메시지에 AI로 답장",
+  "channel_discord.aiAutoReply.fields.enabledHelp": "기본값은 꺼짐입니다. 켜면 단순한 메시지는 자동으로 답장되고, 민감하거나 확신이 낮거나 의심스러운 내용은 사람이 승인하도록 제안됩니다.",
+  "channel_discord.aiAutoReply.intro": "이 Discord 채널이 스스로 답장할 수 있는지, 그리고 어떤 에이전트가 답장을 작성할지 선택하세요.",
+  "channel_discord.aiAutoReply.lastError": "이 채널의 마지막 자동 응답 시도는 아무것도 만들어내지 못했습니다: {reason}",
+  "channel_discord.aiAutoReply.lastErrorAt": "(최초 발견 {at})",
+  "channel_discord.aiAutoReply.loading": "AI 자동 응답 설정을 불러오는 중...",
+  "channel_discord.aiAutoReply.loadingChannels": "Discord 채널을 불러오는 중...",
+  "channel_discord.aiAutoReply.notFound": "Discord 채널을 찾을 수 없습니다",
+  "channel_discord.aiAutoReply.page.title": "Discord AI 자동 응답",
+  "channel_discord.aiAutoReply.save": "저장",
+  "channel_discord.aiAutoReply.saved": "AI 자동 응답 설정을 저장했습니다.",
+  "channel_discord.aiAutoReply.unavailable": "이 배포에는 AI 어시스턴트 모듈이 설치되어 있지 않아 자동 응답을 켤 수 없습니다. 채널은 일반 수신함으로 계속 동작합니다.",
+  "channel_discord.aiAutoReply.widget.configure": "설정",
+  "channel_discord.aiAutoReply.widget.description": "AI 에이전트가 수신된 Discord 메시지에 답장하도록 할 수 있습니다. 모든 채널은 기본적으로 꺼져 있으며, 민감하거나 확신이 낮은 내용은 전송되지 않고 사람이 승인하도록 제안됩니다.",
+  "channel_discord.aiAutoReply.widget.failing": "자동 응답 실패 중",
+  "channel_discord.aiAutoReply.widget.lastError": "마지막 시도 실패: {reason}",
+  "channel_discord.aiAutoReply.widget.noAgent": "선택된 에이전트 없음",
+  "channel_discord.aiAutoReply.widget.noChannels": "먼저 Discord 봇을 연결하세요 — 자동 응답은 채널별로 설정합니다.",
+  "channel_discord.aiAutoReply.widget.off": "자동 응답 꺼짐",
+  "channel_discord.aiAutoReply.widget.on": "자동 응답 켜짐",
+  "channel_discord.aiAutoReply.widget.title": "AI 자동 응답",
+  "channel_discord.aiAutoReply.widget.truncated": "최근 채널만 표시됩니다. 나머지는 채널 목록에서 채널을 열어 설정하세요.",
+  "channel_discord.aiProposal.actions.approve": "승인하고 전송",
+  "channel_discord.aiProposal.actions.dismiss": "무시",
+  "channel_discord.aiProposal.messageType": "제안된 Discord 답장",
+  "channel_discord.connect.blocked": "유효성 검사로 인해 연결이 차단되었습니다",
+  "channel_discord.connect.button": "Discord 연결",
+  "channel_discord.connect.cancel": "취소",
+  "channel_discord.connect.connected": "Discord 채널이 연결되었습니다.",
+  "channel_discord.connect.connecting": "연결 중...",
+  "channel_discord.connect.failed": "Discord 봇을 연결하지 못했습니다.",
+  "channel_discord.connect.fields.applicationId": "애플리케이션 ID",
+  "channel_discord.connect.fields.botToken": "봇 토큰",
+  "channel_discord.connect.fields.defaultChannelId": "기본 채널 ID",
+  "channel_discord.connect.fields.displayName": "표시 이름",
+  "channel_discord.connect.fields.guildId": "길드(서버) ID",
+  "channel_discord.connect.fields.publicKey": "공개 키",
+  "channel_discord.connect.save": "연결",
+  "channel_discord.connect.title": "Discord 봇 연결",
+  "channel_discord.interactions.commandReceived": "접수됨 — `/{command}` 이(가) Open Mercato 받은편지함에 등록되었으며 담당자가 이어서 처리합니다.",
+  "channel_discord.interactions.componentReceived": "접수됨 — 응답이 Open Mercato 받은편지함에 등록되었으며 담당자가 이어서 처리합니다.",
+  "channel_discord.interactions.dispatchFailed": "Open Mercato가 지금은 이 상호작용을 기록하지 못했습니다. 잠시 후 다시 시도해 주세요.",
+  "channel_discord.interactions.notDispatchable": "이 상호작용에는 Open Mercato에 필요한 채널 또는 사용자 정보가 없어 기록되지 않았습니다.",
+  "channel_discord.interactions.unsupported": "Open Mercato Discord 채널은 이 상호작용 유형을 처리하지 않습니다.",
+  "channel_discord.provider.label": "Discord"
+}

package/src/modules/channel_discord/i18n/pl.json

@@ -0,0 +1,57 @@
+{
+  "channel_discord.aiAutoReply.errors.agentFeaturesMissing": "Użytkownik-bot kanału nie ma uprawnień wymaganych przez tego agenta: {features}. Nadaj je najpierw albo wybierz innego agenta.",
+  "channel_discord.aiAutoReply.errors.agentNotEligible": "Ten agent nie może odpowiadać na kanale — wybierz takiego, który zwraca ustrukturyzowany wynik",
+  "channel_discord.aiAutoReply.errors.agentRequired": "Wybierz agenta, który ma odpowiadać na tym kanale",
+  "channel_discord.aiAutoReply.errors.aiUnavailable": "Automatyczne odpowiedzi wymagają modułu asystenta AI, którego nie ma w tym wdrożeniu",
+  "channel_discord.aiAutoReply.errors.load": "Nie udało się wczytać ustawień automatycznych odpowiedzi AI",
+  "channel_discord.aiAutoReply.errors.loadChannels": "Nie udało się wczytać kanałów Discord",
+  "channel_discord.aiAutoReply.errors.save": "Nie udało się zapisać ustawień automatycznych odpowiedzi AI",
+  "channel_discord.aiAutoReply.fields.agent": "Agent",
+  "channel_discord.aiAutoReply.fields.agentHelp": "Na kanale mogą odpowiadać tylko agenci zwracający ustrukturyzowany wynik. Zanim wybierzesz agenta z innego modułu, nadaj użytkownikowi-botowi tenanta uprawnienia wymagane przez tego agenta.",
+  "channel_discord.aiAutoReply.fields.agentMissingFeatures": "{label} — wymaga {features}",
+  "channel_discord.aiAutoReply.fields.enabled": "Odpowiadaj na przychodzące wiadomości Discord przy pomocy AI",
+  "channel_discord.aiAutoReply.fields.enabledHelp": "Domyślnie wyłączone. Po włączeniu proste wiadomości otrzymują odpowiedź automatycznie; wszystko wrażliwe, niepewne lub podejrzane trafia do zatwierdzenia przez człowieka.",
+  "channel_discord.aiAutoReply.intro": "Zdecyduj, czy ten kanał Discord może odpowiadać samodzielnie i który agent ma przygotowywać odpowiedź.",
+  "channel_discord.aiAutoReply.lastError": "Ostatnia próba automatycznej odpowiedzi na tym kanale nic nie dała: {reason}",
+  "channel_discord.aiAutoReply.lastErrorAt": "(pierwszy raz {at})",
+  "channel_discord.aiAutoReply.loading": "Wczytywanie ustawień automatycznych odpowiedzi AI...",
+  "channel_discord.aiAutoReply.loadingChannels": "Wczytywanie kanałów Discord...",
+  "channel_discord.aiAutoReply.notFound": "Nie znaleziono kanału Discord",
+  "channel_discord.aiAutoReply.page.title": "Automatyczne odpowiedzi AI na Discordzie",
+  "channel_discord.aiAutoReply.save": "Zapisz",
+  "channel_discord.aiAutoReply.saved": "Zapisano ustawienia automatycznych odpowiedzi AI.",
+  "channel_discord.aiAutoReply.unavailable": "W tym wdrożeniu nie zainstalowano modułu asystenta AI, więc nie można włączyć automatycznych odpowiedzi. Kanał nadal działa jak zwykła skrzynka odbiorcza.",
+  "channel_discord.aiAutoReply.widget.configure": "Konfiguruj",
+  "channel_discord.aiAutoReply.widget.description": "Pozwól agentowi AI odpowiadać na przychodzące wiadomości Discord. Każdy kanał jest domyślnie wyłączony, a treści wrażliwe lub niepewne trafiają do zatwierdzenia przez człowieka zamiast zostać wysłane.",
+  "channel_discord.aiAutoReply.widget.failing": "Automatyczne odpowiedzi zawodzą",
+  "channel_discord.aiAutoReply.widget.lastError": "Ostatnia próba nieudana: {reason}",
+  "channel_discord.aiAutoReply.widget.noAgent": "Nie wybrano agenta",
+  "channel_discord.aiAutoReply.widget.noChannels": "Najpierw połącz bota Discord — automatyczne odpowiedzi konfiguruje się osobno dla każdego kanału.",
+  "channel_discord.aiAutoReply.widget.off": "Odpowiedzi wyłączone",
+  "channel_discord.aiAutoReply.widget.on": "Odpowiedzi włączone",
+  "channel_discord.aiAutoReply.widget.title": "Automatyczne odpowiedzi AI",
+  "channel_discord.aiAutoReply.widget.truncated": "Pokazano tylko najnowsze kanały. Pozostałe skonfigurujesz, otwierając kanał na liście kanałów.",
+  "channel_discord.aiProposal.actions.approve": "Zatwierdź i wyślij",
+  "channel_discord.aiProposal.actions.dismiss": "Odrzuć",
+  "channel_discord.aiProposal.messageType": "Propozycja odpowiedzi na Discordzie",
+  "channel_discord.connect.blocked": "Połączenie zablokowane przez walidację",
+  "channel_discord.connect.button": "Połącz Discord",
+  "channel_discord.connect.cancel": "Anuluj",
+  "channel_discord.connect.connected": "Kanał Discord połączony.",
+  "channel_discord.connect.connecting": "Łączenie...",
+  "channel_discord.connect.failed": "Nie udało się połączyć bota Discord.",
+  "channel_discord.connect.fields.applicationId": "ID aplikacji",
+  "channel_discord.connect.fields.botToken": "Token bota",
+  "channel_discord.connect.fields.defaultChannelId": "Domyślne ID kanału",
+  "channel_discord.connect.fields.displayName": "Nazwa wyświetlana",
+  "channel_discord.connect.fields.guildId": "ID serwera (guild)",
+  "channel_discord.connect.fields.publicKey": "Klucz publiczny",
+  "channel_discord.connect.save": "Połącz",
+  "channel_discord.connect.title": "Połącz bota Discord",
+  "channel_discord.interactions.commandReceived": "Odebrano — `/{command}` trafiło do skrzynki Open Mercato i ktoś się tym zajmie.",
+  "channel_discord.interactions.componentReceived": "Odebrano — Twoja odpowiedź trafiła do skrzynki Open Mercato i ktoś się tym zajmie.",
+  "channel_discord.interactions.dispatchFailed": "Open Mercato nie mogło teraz zapisać tej interakcji. Spróbuj ponownie za chwilę.",
+  "channel_discord.interactions.notDispatchable": "Tej interakcji brakuje kontekstu kanału lub użytkownika, którego potrzebuje Open Mercato, więc nie została zapisana.",
+  "channel_discord.interactions.unsupported": "Kanał Discord w Open Mercato nie obsługuje tego typu interakcji.",
+  "channel_discord.provider.label": "Discord"
+}

package/src/modules/channel_discord/index.ts

@@ -0,0 +1,6 @@
+export const metadata = {
+  id: 'channel_discord',
+  title: 'Discord Communication Channel',
+  description:
+    'Connect a Discord bot as a two-way communication channel. Outbound via the Discord REST API; inbound in real time via a Gateway worker; signed (Ed25519) Interactions endpoint that acknowledges slash commands / buttons. Optional per-channel AI auto-reply answers straightforward messages and proposes the rest for human approval. Pairs with the Communications Hub.',
+}

package/src/modules/channel_discord/integration.ts

@@ -0,0 +1,98 @@
+import { buildIntegrationDetailWidgetSpotId, type IntegrationBundle, type IntegrationDefinition } from '@open-mercato/shared/modules/integrations/types'
+
+export const channelDiscordDetailWidgetSpotId = buildIntegrationDetailWidgetSpotId('channel_discord')
+
+export const integration: IntegrationDefinition = {
+  id: 'channel_discord',
+  title: 'Discord',
+  // Kept within the 68–132 character range the six sibling providers occupy: the
+  // card grid gives every description the same fixed box, so a long one inflates
+  // its whole row. The operational caveats it used to carry (gateway worker,
+  // queue strategy) belong on the detail page and in the credential help texts,
+  // which is where they now live.
+  description: 'Two-way Discord bot channel: REST outbound, real-time Gateway inbound, optional AI auto-reply.',
+  category: 'communication',
+  hub: 'communication_channels',
+  providerKey: 'discord',
+  icon: 'discord',
+  docsUrl: 'https://discord.com/developers/docs/intro',
+  package: '@open-mercato/channel-discord',
+  // The provider descriptor's own version, deliberately independent of the
+  // monorepo release the package happens to ship in — a copied monorepo version
+  // rots on every release bump and reads as a claim it is not making.
+  version: '1.0.0',
+  author: 'Open Mercato Team',
+  company: 'Open Mercato',
+  license: 'MIT',
+  // `ai` returns here in the same change that makes auto-reply real: an agent the
+  // repository ships, a service principal with real features, a settings surface
+  // that arms it, and an approval surface for everything it must not send.
+  tags: ['discord', 'chat', 'bot', 'gateway', 'communication', 'ai'],
+  detailPage: {
+    widgetSpotId: channelDiscordDetailWidgetSpotId,
+  },
+  apiVersions: [
+    {
+      id: 'v10',
+      label: 'Discord API v10',
+      status: 'stable',
+      default: true,
+      changelog: 'Discord API v10 (REST) + Gateway v10 real-time inbound + Ed25519-signed Interactions.',
+    },
+  ],
+  credentials: {
+    fields: [
+      {
+        key: 'botToken',
+        label: 'Bot token',
+        type: 'secret',
+        required: true,
+        helpText:
+          'Developer Portal → Applications → your app → Bot → Reset Token. Grants full control of the bot user. Stored encrypted at rest; never logged.',
+      },
+      {
+        key: 'applicationId',
+        label: 'Application ID',
+        type: 'text',
+        required: true,
+        placeholder: '123456789012345678',
+        helpText:
+          'Developer Portal → General Information → Application ID. Used to register slash commands'
+          + ' (mercato channel_discord register-slash-commands) and to answer interactions.',
+      },
+      {
+        key: 'publicKey',
+        label: 'Public key',
+        type: 'text',
+        required: true,
+        placeholder: '64-character hex Ed25519 public key',
+        helpText:
+          'Developer Portal → General Information → Public Key. Verifies signed interaction requests; a verified'
+          + ' slash command or button press is recorded in the inbox and answered back in Discord.',
+      },
+      {
+        key: 'guildId',
+        label: 'Guild (server) ID',
+        type: 'text',
+        required: false,
+        placeholder: '123456789012345678',
+        helpText: 'Recommended: scope the bot to a single server. Enable Developer Mode in Discord, right-click the server, Copy Server ID.',
+      },
+      {
+        key: 'defaultChannelId',
+        label: 'Default channel ID',
+        type: 'text',
+        required: false,
+        placeholder: '123456789012345678',
+        helpText:
+          'Default text channel the adapter posts to when an outbound message names no Discord channel. The hub'
+          + ' test-send endpoint accepts a channel snowflake as its recipient, so you can use it to verify this end to end.',
+      },
+    ],
+  },
+  healthCheck: { service: 'channelDiscordHealthCheck' },
+}
+
+export const integrations: IntegrationDefinition[] = [integration]
+export const bundles: IntegrationBundle[] = []
+export const bundle: IntegrationBundle | undefined = undefined

package/src/modules/channel_discord/lib/__tests__/adapter.test.ts

@@ -0,0 +1,206 @@
+import { generateKeyPairSync, sign as cryptoSign } from 'node:crypto'
+import { getDiscordChannelAdapter } from '../adapter'
+import {
+  setDiscordRestClient,
+  type CreateMessageInput,
+  type DiscordMessageObject,
+  type DiscordRestClient,
+  type DiscordUser,
+} from '../discord-rest'
+import { DISCORD_CONVERSATION_PREFIX } from '../normalize-inbound'
+
+function makeSigner() {
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519')
+  const spki = publicKey.export({ type: 'spki', format: 'der' }) as Buffer
+  return {
+    publicKeyHex: spki.subarray(spki.length - 32).toString('hex'),
+    sign: (message: string) => cryptoSign(null, Buffer.from(message, 'utf-8'), privateKey).toString('hex'),
+  }
+}
+
+function stubRest(overrides: Partial<DiscordRestClient> = {}): {
+  captured: { createMessage?: CreateMessageInput }
+} {
+  const captured: { createMessage?: CreateMessageInput } = {}
+  const base: DiscordRestClient = {
+    async createMessage(_auth, input): Promise<DiscordMessageObject> {
+      captured.createMessage = input
+      return {
+        id: 'sent-1',
+        channel_id: input.channelId,
+        content: input.content,
+        author: { id: 'bot', username: 'bot' },
+        timestamp: '2026-06-19T10:00:00.000Z',
+      }
+    },
+    async editMessage(_a, channelId, _m, content) {
+      return { id: 'm', channel_id: channelId, content, author: { id: 'b', username: 'b' }, timestamp: '' }
+    },
+    async deleteMessage() {},
+    async addReaction() {},
+    async removeReaction() {},
+    async listMessages() {
+      return []
+    },
+    async getCurrentUser(): Promise<DiscordUser> {
+      return { id: 'bot-user', username: 'bot' }
+    },
+    async getGatewayBot() {
+      return { url: 'wss://gateway', shards: 1 }
+    },
+    async registerGuildCommands() {},
+    ...overrides,
+  }
+  setDiscordRestClient(base)
+  return { captured }
+}
+
+const credentials = {
+  botToken: 'bot-token-abc',
+  applicationId: '123',
+  publicKey: 'a'.repeat(64),
+}
+
+afterEach(() => setDiscordRestClient(null))
+
+describe('DiscordChannelAdapter.sendMessage', () => {
+  it('builds a REST createMessage request against the resolved channel id', async () => {
+    const { captured } = stubRest()
+    const adapter = getDiscordChannelAdapter()
+    const result = await adapter.sendMessage({
+      conversationId: `${DISCORD_CONVERSATION_PREFIX}chan-77`,
+      content: { text: 'hi there', bodyFormat: 'markdown' },
+      credentials,
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(captured.createMessage?.channelId).toBe('chan-77')
+    expect(captured.createMessage?.content).toBe('hi there')
+    expect(result.status).toBe('sent')
+    expect(result.externalMessageId).toBe('sent-1')
+    expect(result.conversationId).toBe(`${DISCORD_CONVERSATION_PREFIX}chan-77`)
+  })
+
+  it('falls back to defaultChannelId when no conversation id is given', async () => {
+    const { captured } = stubRest()
+    const adapter = getDiscordChannelAdapter()
+    await adapter.sendMessage({
+      content: { text: 'x' },
+      credentials: { ...credentials, defaultChannelId: 'default-chan' },
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(captured.createMessage?.channelId).toBe('default-chan')
+  })
+
+  it('posts to the recipient the hub resolved, instead of silently using the default', async () => {
+    // QA of #4391 against a live bot: the hub's test-send route puts the
+    // operator's recipient in `metadata.to`, nothing read it, and every send
+    // went to `defaultChannelId` while the endpoint answered `200 sent`. A
+    // recipient that is validated and then discarded is worse than one that is
+    // rejected — the operator gets a success for a message that went elsewhere.
+    const { captured } = stubRest()
+    const adapter = getDiscordChannelAdapter()
+    await adapter.sendMessage({
+      content: { text: 'x' },
+      credentials: { ...credentials, defaultChannelId: 'default-chan' },
+      metadata: { to: 'requested-chan', testSend: true },
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(captured.createMessage?.channelId).toBe('requested-chan')
+  })
+
+  it('never lets a stray recipient redirect a reply out of its own conversation', async () => {
+    // `conversationId` outranks `metadata.to` on purpose: on a reply the thread
+    // mapping is authoritative.
+    const { captured } = stubRest()
+    const adapter = getDiscordChannelAdapter()
+    await adapter.sendMessage({
+      conversationId: `${DISCORD_CONVERSATION_PREFIX}thread-chan`,
+      content: { text: 'x' },
+      credentials: { ...credentials, defaultChannelId: 'default-chan' },
+      metadata: { to: 'somewhere-else' },
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(captured.createMessage?.channelId).toBe('thread-chan')
+  })
+
+  it('clamps content to Discord 2000-char limit', async () => {
+    const { captured } = stubRest()
+    const adapter = getDiscordChannelAdapter()
+    await adapter.sendMessage({
+      conversationId: 'chan',
+      content: { text: 'a'.repeat(5000), bodyFormat: 'markdown' },
+      credentials,
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(captured.createMessage?.content.length).toBe(2000)
+  })
+})
+
+describe('DiscordChannelAdapter.verifyWebhook (fail-closed)', () => {
+  const signer = makeSigner()
+  const creds = { ...credentials, publicKey: signer.publicKeyHex }
+  const timestamp = '1700000000'
+  const rawBody = JSON.stringify({ type: 1 })
+
+  it('returns eventType other for a validly signed interaction', async () => {
+    const adapter = getDiscordChannelAdapter()
+    const result = await adapter.verifyWebhook({
+      rawBody,
+      headers: {
+        'x-signature-ed25519': signer.sign(timestamp + rawBody),
+        'x-signature-timestamp': timestamp,
+      },
+      credentials: creds,
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(result.eventType).toBe('other')
+  })
+
+  it('throws on a tampered interaction signature', async () => {
+    const adapter = getDiscordChannelAdapter()
+    await expect(
+      adapter.verifyWebhook({
+        rawBody,
+        headers: {
+          'x-signature-ed25519': signer.sign(timestamp + '{"type":2}'),
+          'x-signature-timestamp': timestamp,
+        },
+        credentials: creds,
+        scope: { organizationId: 'o', tenantId: 't' },
+      }),
+    ).rejects.toThrow()
+  })
+
+  it('returns eventType other for a non-interaction body (gateway-delivered messages)', async () => {
+    const adapter = getDiscordChannelAdapter()
+    const result = await adapter.verifyWebhook({
+      rawBody: JSON.stringify({ not: 'an interaction' }),
+      headers: {},
+      credentials: creds,
+      scope: { organizationId: 'o', tenantId: 't' },
+    })
+    expect(result.eventType).toBe('other')
+  })
+})
+
+describe('DiscordChannelAdapter.validateCredentials', () => {
+  it('accepts a good token (users/@me succeeds)', async () => {
+    stubRest()
+    const adapter = getDiscordChannelAdapter()
+    const result = await adapter.validateCredentials({ providerKey: 'discord', credentials, scope: { organizationId: 'o', tenantId: 't' } })
+    expect(result.ok).toBe(true)
+  })
+
+  it('rejects a bad token with a field error', async () => {
+    stubRest({
+      async getCurrentUser() {
+        const { DiscordApiError } = await import('../discord-rest')
+        throw new DiscordApiError('unauthorized', 401, 'unauthorized')
+      },
+    })
+    const adapter = getDiscordChannelAdapter()
+    const result = await adapter.validateCredentials({ providerKey: 'discord', credentials, scope: { organizationId: 'o', tenantId: 't' } })
+    expect(result.ok).toBe(false)
+    expect(result.errors?.botToken).toBeTruthy()
+  })
+})

package/src/modules/channel_discord/lib/__tests__/ai-agent-directory.test.ts

@@ -0,0 +1,61 @@
+import { missingAgentFeatures } from '../ai-agent-directory'
+
+/**
+ * The authorization half of "can auto-reply invoke this agent" (issue #4778).
+ *
+ * `listDiscordEligibleAgents` only answers the shape question — object-mode, so
+ * `runAiAgentObject` will take the call. The runtime then runs the agent's
+ * `requiredFeatures` against the auto-reply principal, and an agent that clears
+ * the first check but fails the second is exactly the setting that arms a channel
+ * which then answers nothing, forever, inside a background subscriber.
+ *
+ * These cases pin the comparison against the platform's real `authorizeFeatures`
+ * rather than a stub, because the wildcard rows are the ones a hand-rolled
+ * `Set.has` would get wrong — and getting them wrong means refusing a channel-bot
+ * user whose role legitimately covers the agent.
+ */
+describe('missingAgentFeatures', () => {
+  const principal = (features: string[], isSuperAdmin = false) => ({ features, isSuperAdmin })
+
+  it('treats an agent that requires nothing as invocable by anyone', () => {
+    expect(missingAgentFeatures([], principal([]))).toEqual([])
+    expect(missingAgentFeatures(undefined, principal([]))).toEqual([])
+  })
+
+  it('accepts an exact grant', () => {
+    expect(missingAgentFeatures(['customers.view'], principal(['customers.view']))).toEqual([])
+  })
+
+  it('names every required feature the principal does not hold', () => {
+    const missing = missingAgentFeatures(
+      ['customers.view', 'customers.manage', 'sales.view'],
+      principal(['customers.view']),
+    )
+    expect(missing).toEqual(['customers.manage', 'sales.view'])
+  })
+
+  it('honours a module wildcard grant the way the runtime does', () => {
+    expect(missingAgentFeatures(['customers.view'], principal(['customers.*']))).toEqual([])
+  })
+
+  it('honours a global wildcard grant', () => {
+    expect(missingAgentFeatures(['customers.view', 'sales.view'], principal(['*']))).toEqual([])
+  })
+
+  it('does not let a sibling-module grant stand in for the required one', () => {
+    expect(missingAgentFeatures(['customers.view'], principal(['sales.*']))).toEqual(['customers.view'])
+  })
+
+  it('reports the provider agent as invocable under the service principal alone', () => {
+    // The provider's own agent is what has to work with no operator setup at all.
+    const missing = missingAgentFeatures(
+      ['channel_discord.ai_auto_reply.run'],
+      principal(['channel_discord.ai_auto_reply.run']),
+    )
+    expect(missing).toEqual([])
+  })
+
+  it('is not satisfied by an empty principal, which is what a features:[] regression looks like', () => {
+    expect(missingAgentFeatures(['customers.view'], principal([]))).toEqual(['customers.view'])
+  })
+})