Discord (API Bot)

Statut : operationnel pour les DMs et les salons de serveur via la gateway Discord officielle.

• Appairage — Les DMs Discord utilisent le mode appairage par defaut.
• Commandes slash — Comportement des commandes natives et catalogue.
• Depannage des canaux — Diagnostics et procedures de reparation inter-canaux.

Configuration rapide

Vous devez creer une nouvelle application avec un bot, ajouter le bot a votre serveur et le connecter a OpenClaw. Nous recommandons d’ajouter votre bot a votre propre serveur prive. Si vous n’en avez pas encore, creez-en un d’abord (choisissez Creer le mien > Pour moi et mes amis).

Etape 1 : creer une application Discord et un bot

Rendez-vous sur le [portail developpeur Discord](https://discord.com/developers/applications) et cliquez sur **New Application**. Nommez-le par exemple « OpenClaw ».

Cliquez sur **Bot** dans la barre laterale. Definissez le **Username** selon le nom que vous donnez a votre agent OpenClaw.

Etape 2 : activer les intents privilegies

Toujours sur la page **Bot**, descendez jusqu'a **Privileged Gateway Intents** et activez :

- **Message Content Intent** (obligatoire)
- **Server Members Intent** (recommande ; necessaire pour les listes d'autorisation par role et la correspondance nom-ID)
- **Presence Intent** (optionnel ; uniquement pour les mises a jour de presence)

Etape 3 : copier le token du bot

Remontez sur la page **Bot** et cliquez sur **Reset Token**.

> **Remarque :** Malgre le nom, ceci genere votre premier token — rien n'est « reinitialise ».

Copiez le token et conservez-le. C'est votre **Bot Token**, vous en aurez besoin sous peu.

Etape 4 : generer une URL d’invitation et ajouter le bot a votre serveur

Cliquez sur **OAuth2** dans la barre laterale. Vous allez generer une URL d'invitation avec les bonnes permissions pour ajouter le bot a votre serveur.

Descendez jusqu'a **OAuth2 URL Generator** et activez :

- `bot`
- `applications.commands`

Une section **Bot Permissions** apparaitra en dessous. Activez :

- View Channels
- Send Messages
- Read Message History
- Embed Links
- Attach Files
- Add Reactions (optionnel)

Copiez l'URL generee en bas, collez-la dans votre navigateur, selectionnez votre serveur et cliquez sur **Continue** pour connecter. Vous devriez maintenant voir votre bot sur le serveur Discord.

Etape 5 : activer le mode developpeur et collecter vos identifiants

De retour dans l'application Discord, vous devez activer le mode developpeur pour pouvoir copier les identifiants internes.

1. Cliquez sur **Parametres utilisateur** (icone engrenage a cote de votre avatar) → **Avance** → activez **Mode developpeur**
2. Faites un clic droit sur l'**icone de votre serveur** dans la barre laterale → **Copier l'identifiant du serveur**
3. Faites un clic droit sur votre **propre avatar** → **Copier l'identifiant de l'utilisateur**

Conservez votre **Server ID** et votre **User ID** a cote de votre Bot Token — vous les enverrez tous les trois a OpenClaw a l'etape suivante.

Etape 6 : autoriser les DMs des membres du serveur

Pour que l'appairage fonctionne, Discord doit autoriser votre bot a vous envoyer des DMs. Faites un clic droit sur l'**icone de votre serveur** → **Parametres de confidentialite** → activez **Messages prives**.

Cela permet aux membres du serveur (y compris les bots) de vous envoyer des DMs. Gardez cette option activee si vous souhaitez utiliser les DMs Discord avec OpenClaw. Si vous prevoyez d'utiliser uniquement les salons de serveur, vous pouvez desactiver les DMs apres l'appairage.

Etape 7 : definir le token du bot en toute securite (ne l’envoyez pas dans le chat)

Votre token de bot Discord est un secret (comme un mot de passe). Definissez-le sur la machine executant OpenClaw avant d'envoyer un message a votre agent.

openclaw config set channels.discord.token '"YOUR_BOT_TOKEN"' --json
openclaw config set channels.discord.enabled true --json
openclaw gateway

Si OpenClaw tourne deja en service d'arriere-plan, utilisez `openclaw gateway restart` a la place.

Etape 8 : configurer OpenClaw et proceder a l’appairage

  #### Demandez a votre agent
    Discutez avec votre agent OpenClaw sur un canal existant (par ex. Telegram) et indiquez-lui. Si Discord est votre premier canal, utilisez l'onglet CLI / config a la place.

    > « J'ai deja defini mon token de bot Discord dans la configuration. Termine la configuration Discord avec l'User ID `<user_id>` et le Server ID `<server_id>`. »

  #### CLI / config
    Si vous preferez la configuration par fichier :

{
  channels: {
    discord: {
      enabled: true,
      token: "YOUR_BOT_TOKEN",
    },
  },
}

    Variable d'environnement de secours pour le compte par defaut :

DISCORD_BOT_TOKEN=...

    Les valeurs SecretRef sont egalement prises en charge pour `channels.discord.token` (fournisseurs env/file/exec). Voir [Gestion des secrets](/docs/gateway/secrets).

Etape 9 : approuver le premier appairage DM

Attendez que la gateway soit en cours d'execution, puis envoyez un DM a votre bot sur Discord. Il repondra avec un code d'appairage.


  #### Demandez a votre agent
    Envoyez le code d'appairage a votre agent sur votre canal existant :

    > « Approuve ce code d'appairage Discord : `<CODE>` »

  #### CLI

openclaw pairing list discord
openclaw pairing approve discord <CODE>

Les codes d'appairage expirent apres 1 heure.

Vous devriez maintenant pouvoir discuter avec votre agent sur Discord via DM.

Remarque : La resolution du token tient compte des comptes. Les valeurs de token en configuration ont priorite sur la variable d’environnement de secours. DISCORD_BOT_TOKEN n’est utilise que pour le compte par defaut. Pour les appels sortants avances (outil message/actions de canal), un token explicite par appel est utilise. Les parametres de politique/reessai du compte proviennent toujours du compte selectionne dans l’instantane d’execution actif.

Recommande : configurer un espace de travail de serveur

Une fois les DMs fonctionnels, vous pouvez configurer votre serveur Discord comme un espace de travail complet ou chaque salon obtient sa propre session d’agent avec son propre contexte. C’est recommande pour les serveurs prives ou il n’y a que vous et votre bot.

Etape 1 : ajouter votre serveur a la liste d’autorisation des serveurs

Cela permet a votre agent de repondre dans n'importe quel salon de votre serveur, pas seulement en DM.


  #### Demandez a votre agent
    > « Ajoute mon Server ID Discord `<server_id>` a la liste d'autorisation des serveurs »

  #### Config

{
  channels: {
    discord: {
      groupPolicy: "allowlist",
      guilds: {
        YOUR_SERVER_ID: {
          requireMention: true,
          users: ["YOUR_USER_ID"],
        },
      },
    },
  },
}

Etape 2 : autoriser les reponses sans @mention

Par defaut, votre agent ne repond dans les salons de serveur que lorsqu'il est @mentionne. Pour un serveur prive, vous souhaiterez probablement qu'il reponde a chaque message.


  #### Demandez a votre agent
    > « Autorise mon agent a repondre sur ce serveur sans devoir etre @mentionne »

  #### Config
    Definissez `requireMention: false` dans la configuration de votre serveur :

{
  channels: {
    discord: {
      guilds: {
        YOUR_SERVER_ID: {
          requireMention: false,
        },
      },
    },
  },
}

Etape 3 : planifier la memoire dans les salons de serveur

Par defaut, la memoire a long terme (MEMORY.md) ne se charge que dans les sessions DM. Les salons de serveur ne chargent pas automatiquement MEMORY.md.


  #### Demandez a votre agent
    > « Quand je pose des questions dans les salons Discord, utilise memory_search ou memory_get si tu as besoin du contexte a long terme de MEMORY.md. »

  #### Manuel
    Si vous avez besoin d'un contexte partage dans chaque salon, placez les instructions stables dans `AGENTS.md` ou `USER.md` (ils sont injectes pour chaque session). Conservez les notes a long terme dans `MEMORY.md` et accedez-y a la demande avec les outils memoire.

Creez maintenant des salons sur votre serveur Discord et commencez a discuter. Votre agent peut voir le nom du salon, et chaque salon obtient sa propre session isolee — vous pouvez ainsi creer #coding, #home, #research, ou tout ce qui convient a votre flux de travail.

Modele d’execution

• La gateway possede la connexion Discord.
• Le routage des reponses est deterministe : les messages entrants Discord sont renvoyes vers Discord.
• Par defaut (session.dmScope=main), les conversations directes partagent la session principale de l’agent (agent:main:main).
• Les salons de serveur sont des cles de session isolees (agent:<agentId>:discord:channel:<channelId>).
• Les DMs de groupe sont ignores par defaut (channels.discord.dm.groupEnabled=false).
• Les commandes slash natives s’executent dans des sessions de commande isolees (agent:<agentId>:discord:slash:<userId>), tout en portant la CommandTargetSessionKey vers la session de conversation routee.

Salons forum

Les salons forum et media Discord n’acceptent que les publications de fils. OpenClaw propose deux facons de les creer :

• Envoyez un message au parent du forum (channel:<forumId>) pour creer automatiquement un fil. Le titre du fil utilise la premiere ligne non vide de votre message.
• Utilisez openclaw message thread create pour creer directement un fil. Ne passez pas --message-id pour les salons forum.

Exemple : envoyer au parent du forum pour creer un fil

openclaw message send --channel discord --target channel:<forumId> \
  --message "Topic title\nBody of the post"

Exemple : creer explicitement un fil de forum

openclaw message thread create --channel discord --target channel:<forumId> \
  --thread-name "Topic title" --message "Body of the post"

Les parents de forum n’acceptent pas les composants Discord. Si vous avez besoin de composants, envoyez au fil lui-meme (channel:<threadId>).

Composants interactifs

OpenClaw prend en charge les conteneurs de composants v2 Discord pour les messages d’agents. Utilisez l’outil message avec un payload components. Les resultats d’interaction sont routes vers l’agent comme des messages entrants normaux et suivent les parametres replyToMode Discord existants.

Blocs pris en charge :

• text, section, separator, actions, media-gallery, file
• Les lignes d’actions autorisent jusqu’a 5 boutons ou un seul menu de selection
• Types de selection : string, user, role, mentionable, channel

Par defaut, les composants sont a usage unique. Definissez components.reusable=true pour permettre aux boutons, selections et formulaires d’etre utilises plusieurs fois jusqu’a expiration.

Pour restreindre qui peut cliquer sur un bouton, definissez allowedUsers sur ce bouton (identifiants Discord, tags ou *). Lorsque c’est configure, les utilisateurs non autorises recoivent un refus ephemere.

Les commandes slash /model et /models ouvrent un selecteur de modele interactif avec des menus deroulants pour le fournisseur et le modele, plus une etape de validation. La reponse du selecteur est ephemere et seul l’utilisateur invoquant peut l’utiliser.

Pieces jointes :

• Les blocs file doivent pointer vers une reference d’attachment (attachment://<filename>)
• Fournissez la piece jointe via media/path/filePath (fichier unique) ; utilisez media-gallery pour plusieurs fichiers
• Utilisez filename pour remplacer le nom d’upload lorsqu’il doit correspondre a la reference d’attachment

Formulaires modaux :

• Ajoutez components.modal avec jusqu’a 5 champs
• Types de champs : text, checkbox, radio, select, role-select, user-select
• OpenClaw ajoute automatiquement un bouton declencheur

Exemple :

{
  channel: "discord",
  action: "send",
  to: "channel:123456789012345678",
  message: "Optional fallback text",
  components: {
    reusable: true,
    text: "Choose a path",
    blocks: [
      {
        type: "actions",
        buttons: [
          {
            label: "Approve",
            style: "success",
            allowedUsers: ["123456789012345678"],
          },
          { label: "Decline", style: "danger" },
        ],
      },
      {
        type: "actions",
        select: {
          type: "string",
          placeholder: "Pick an option",
          options: [
            { label: "Option A", value: "a" },
            { label: "Option B", value: "b" },
          ],
        },
      },
    ],
    modal: {
      title: "Details",
      triggerLabel: "Open form",
      fields: [
        { type: "text", label: "Requester" },
        {
          type: "select",
          label: "Priority",
          options: [
            { label: "Low", value: "low" },
            { label: "High", value: "high" },
          ],
        },
      ],
    },
  },
}

Controle d’acces et routage

Politique DM

`channels.discord.dmPolicy` controle l'acces DM (ancien : `channels.discord.dm.policy`) :

- `pairing` (par defaut)
- `allowlist`
- `open` (necessite que `channels.discord.allowFrom` contienne `"*"` ; ancien : `channels.discord.dm.allowFrom`)
- `disabled`

Si la politique DM n'est pas ouverte, les utilisateurs inconnus sont bloques (ou invites a l'appairage en mode `pairing`).

Priorite multi-comptes :

- `channels.discord.accounts.default.allowFrom` s'applique uniquement au compte `default`.
- Les comptes nommes heritent de `channels.discord.allowFrom` si leur propre `allowFrom` n'est pas defini.
- Les comptes nommes n'heritent pas de `channels.discord.accounts.default.allowFrom`.

Format de cible DM pour la livraison :

- `user:<id>`
- `<@id>` mention

Les identifiants numeriques seuls sont ambigus et rejetes sauf si un type de cible explicite user/channel est fourni.

Politique serveur

La gestion des serveurs est controlee par `channels.discord.groupPolicy` :

- `open`
- `allowlist`
- `disabled`

La base securisee lorsque `channels.discord` existe est `allowlist`.

Comportement `allowlist` :

- le serveur doit correspondre a `channels.discord.guilds` (`id` prefere, slug accepte)
- listes d'autorisation optionnelles d'expediteurs : `users` (identifiants stables recommandes) et `roles` (identifiants de role uniquement) ; si l'un des deux est configure, les expediteurs sont autorises lorsqu'ils correspondent a `users` OU `roles`
- la correspondance directe par nom/tag est desactivee par defaut ; activez `channels.discord.dangerouslyAllowNameMatching: true` uniquement en mode derogatoire
- les noms/tags sont pris en charge pour `users`, mais les identifiants sont plus surs ; `openclaw security audit` avertit lorsque des entrees nom/tag sont utilisees
- si un serveur a un bloc `channels`, les salons non listes sont refuses
- si un serveur n'a pas de bloc `channels`, tous les salons du serveur autorise sont acceptes

Exemple :

{
  channels: {
    discord: {
      groupPolicy: "allowlist",
      guilds: {
        "123456789012345678": {
          requireMention: true,
          ignoreOtherMentions: true,
          users: ["987654321098765432"],
          roles: ["123456789012345678"],
          channels: {
            general: { allow: true },
            help: { allow: true, requireMention: true },
          },
        },
      },
    },
  },
}

Si vous definissez uniquement `DISCORD_BOT_TOKEN` sans creer de bloc `channels.discord`, le comportement par defaut a l'execution est `groupPolicy="allowlist"` (avec un avertissement dans les logs), meme si `channels.defaults.groupPolicy` est `open`.

Mentions et DMs de groupe

Les messages de serveur sont filtres par mention par defaut.

La detection de mention inclut :

- mention explicite du bot
- motifs de mention configures (`agents.list[].groupChat.mentionPatterns`, secours `messages.groupChat.mentionPatterns`)
- comportement implicite de reponse au bot dans les cas pris en charge

`requireMention` est configure par serveur/salon (`channels.discord.guilds...`).
`ignoreOtherMentions` peut optionnellement ignorer les messages qui mentionnent un autre utilisateur/role mais pas le bot (en excluant @everyone/@here).

DMs de groupe :

- par defaut : ignores (`dm.groupEnabled=false`)
- liste d'autorisation optionnelle via `dm.groupChannels` (identifiants ou slugs de salon)

Routage d’agents par role

Utilisez bindings[].match.roles pour router les membres d’un serveur Discord vers differents agents par identifiant de role. Les bindings par role n’acceptent que les identifiants de role et sont evalues apres les bindings peer ou parent-peer et avant les bindings serveur seul. Si un binding definit aussi d’autres champs de correspondance (par exemple peer + guildId + roles), tous les champs configures doivent correspondre.

{
  bindings: [
    {
      agentId: "opus",
      match: {
        channel: "discord",
        guildId: "123456789012345678",
        roles: ["111111111111111111"],
      },
    },
    {
      agentId: "sonnet",
      match: {
        channel: "discord",
        guildId: "123456789012345678",
      },
    },
  ],
}

Configuration du portail developpeur

1. Portail developpeur Discord -> **Applications** -> **New Application**
2. **Bot** -> **Add Bot**
3. Copiez le token du bot

Dans **Bot -> Privileged Gateway Intents**, activez :

- Message Content Intent
- Server Members Intent (recommande)

L'intent Presence est optionnel et n'est necessaire que pour recevoir les mises a jour de presence. Definir la presence du bot (`setPresence`) ne necessite pas d'activer les mises a jour de presence des membres.

Generateur d'URL OAuth :

- scopes : `bot`, `applications.commands`

Permissions de base typiques :

- View Channels
- Send Messages
- Read Message History
- Embed Links
- Attach Files
- Add Reactions (optionnel)

Evitez `Administrator` sauf si explicitement necessaire.

Activez le mode developpeur Discord, puis copiez :

- identifiant du serveur
- identifiant du salon
- identifiant de l'utilisateur

Privilegiez les identifiants numeriques dans la configuration OpenClaw pour des audits et sondes fiables.

Commandes natives et autorisation des commandes

• commands.native est "auto" par defaut et est active pour Discord.
• Remplacement par canal : channels.discord.commands.native.
• commands.native=false supprime explicitement les commandes natives Discord precedemment enregistrees.
• L’autorisation des commandes natives utilise les memes listes d’autorisation/politiques Discord que la gestion normale des messages.
• Les commandes peuvent rester visibles dans l’interface Discord pour les utilisateurs non autorises ; l’execution applique toujours l’authentification OpenClaw et retourne « not authorized ».

Voir Commandes slash pour le catalogue et le comportement des commandes.

Parametres par defaut des commandes slash :

• ephemeral: true

Details des fonctionnalites

Discord prend en charge les tags de reponse dans la sortie de l'agent :

- `[[reply_to_current]]`
- `[[reply_to:<id>]]`

Controle par `channels.discord.replyToMode` :

- `off` (par defaut)
- `first`
- `all`

> **Remarque :** `off` desactive le fil de reponse implicite. Les tags explicites `[[reply_to_*]]` sont toujours honores.

Les identifiants de message sont exposes dans le contexte/historique pour que les agents puissent cibler des messages specifiques.

OpenClaw peut diffuser les brouillons de reponse en envoyant un message temporaire et en le modifiant au fur et a mesure que le texte arrive.

- `channels.discord.streaming` controle le streaming d'apercu (`off` | `partial` | `block` | `progress`, par defaut : `off`).
- `progress` est accepte pour la coherence inter-canaux et correspond a `partial` sur Discord.
- `channels.discord.streamMode` est un alias ancien et est migre automatiquement.
- `partial` modifie un seul message d'apercu au fur et a mesure que les tokens arrivent.
- `block` emet des morceaux de taille brouillon (utilisez `draftChunk` pour ajuster la taille et les points de coupure).

Exemple :

{
  channels: {
    discord: {
      streaming: "partial",
    },
  },
}

Parametres par defaut du mode `block` (limites a `channels.discord.textChunkLimit`) :

{
  channels: {
    discord: {
      streaming: "block",
      draftChunk: {
        minChars: 200,
        maxChars: 800,
        breakPreference: "paragraph",
      },
    },
  },
}

Le streaming d'apercu est en texte seul ; les reponses media utilisent la livraison normale.

> **Remarque :** Le streaming d'apercu est distinct du streaming par blocs. Lorsque le streaming par blocs est explicitement active pour Discord, OpenClaw saute le flux d'apercu pour eviter un double streaming.

Contexte d'historique de serveur :

- `channels.discord.historyLimit` par defaut `20`
- secours : `messages.groupChat.historyLimit`
- `0` desactive

Controles d'historique DM :

- `channels.discord.dmHistoryLimit`
- `channels.discord.dms["<user_id>"].historyLimit`

Comportement des fils :

- Les fils Discord sont routes comme des sessions de salon
- Les metadonnees du fil parent peuvent etre utilisees pour le lien de session parent
- La configuration du fil herite de la configuration du salon parent sauf si une entree specifique au fil existe

Les sujets de salon sont injectes comme contexte **non fiable** (pas comme prompt systeme).

Discord peut lier un fil a une cible de session afin que les messages suivants dans ce fil continuent de router vers la meme session (y compris les sessions de sous-agents).

Commandes :

- `/focus <target>` lier le fil actuel/nouveau a un sous-agent/cible de session
- `/unfocus` retirer la liaison du fil actuel
- `/agents` afficher les executions actives et l'etat des liaisons
- `/session idle <duration|off>` inspecter/mettre a jour le defocus automatique par inactivite pour les liaisons focalisees
- `/session max-age <duration|off>` inspecter/mettre a jour l'age maximal absolu pour les liaisons focalisees

Configuration :

{
  session: {
    threadBindings: {
      enabled: true,
      idleHours: 24,
      maxAgeHours: 0,
    },
  },
  channels: {
    discord: {
      threadBindings: {
        enabled: true,
        idleHours: 24,
        maxAgeHours: 0,
        spawnSubagentSessions: false, // opt-in
      },
    },
  },
}

Remarques :

- `session.threadBindings.*` definit les valeurs par defaut globales.
- `channels.discord.threadBindings.*` remplace le comportement Discord.
- `spawnSubagentSessions` doit etre a true pour creer/lier automatiquement les fils pour `sessions_spawn({ thread: true })`.
- `spawnAcpSessions` doit etre a true pour creer/lier automatiquement les fils pour ACP (`/acp spawn ... --thread ...` ou `sessions_spawn({ runtime: "acp", thread: true })`).
- Si les liaisons de fils sont desactivees pour un compte, `/focus` et les operations associees ne sont pas disponibles.

Voir [Sous-agents](/docs/tools/subagents), [Agents ACP](/docs/tools/acp-agents) et [Reference de configuration](/docs/gateway/configuration-reference).

Pour des espaces de travail ACP stables et « toujours actifs », configurez des liaisons ACP typees au niveau racine ciblant les conversations Discord.

Chemin de configuration :

- `bindings[]` avec `type: "acp"` et `match.channel: "discord"`

Exemple :

{
  agents: {
    list: [
      {
        id: "codex",
        runtime: {
          type: "acp",
          acp: {
            agent: "codex",
            backend: "acpx",
            mode: "persistent",
            cwd: "/workspace/openclaw",
          },
        },
      },
    ],
  },
  bindings: [
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "discord",
        accountId: "default",
        peer: { kind: "channel", id: "222222222222222222" },
      },
      acp: { label: "codex-main" },
    },
  ],
  channels: {
    discord: {
      guilds: {
        "111111111111111111": {
          channels: {
            "222222222222222222": {
              requireMention: false,
            },
          },
        },
      },
    },
  },
}

Remarques :

- Les messages de fils peuvent heriter de la liaison ACP du salon parent.
- Dans un salon ou fil lie, `/new` et `/reset` reinitialise la meme session ACP en place.
- Les liaisons temporaires de fils fonctionnent toujours et peuvent remplacer la resolution de cible tant qu'elles sont actives.

Voir [Agents ACP](/docs/tools/acp-agents) pour les details du comportement des liaisons.

Mode de notification de reaction par serveur :

- `off`
- `own` (par defaut)
- `all`
- `allowlist` (utilise `guilds.<id>.users`)

Les evenements de reaction sont transformes en evenements systeme et attaches a la session Discord routee.

`ackReaction` envoie un emoji d'accuse de reception pendant qu'OpenClaw traite un message entrant.

Ordre de resolution :

- `channels.discord.accounts.<accountId>.ackReaction`
- `channels.discord.ackReaction`
- `messages.ackReaction`
- emoji de secours de l'identite de l'agent (`agents.list[].identity.emoji`, sinon "eyes")

Remarques :

- Discord accepte les emojis unicode ou les noms d'emoji personnalises.
- Utilisez `""` pour desactiver la reaction pour un canal ou un compte.

Les ecritures de configuration initiees par le canal sont activees par defaut.

Cela concerne les flux `/config set|unset` (lorsque les fonctionnalites de commande sont activees).

Desactivation :

{
  channels: {
    discord: {
      configWrites: false,
    },
  },
}

Routez le trafic WebSocket de la gateway Discord et les requetes REST de demarrage (identifiant d'application + resolution des listes d'autorisation) via un proxy HTTP(S) avec `channels.discord.proxy`.

{
  channels: {
    discord: {
      proxy: "http://proxy.example:8080",
    },
  },
}

Remplacement par compte :

{
  channels: {
    discord: {
      accounts: {
        primary: {
          proxy: "http://proxy.example:8080",
        },
      },
    },
  },
}

Activez la resolution PluralKit pour associer les messages proxies a l'identite du membre systeme :

{
  channels: {
    discord: {
      pluralkit: {
        enabled: true,
        token: "pk_live_...", // optionnel ; necessaire pour les systemes prives
      },
    },
  },
}

Remarques :

- les listes d'autorisation peuvent utiliser `pk:<memberId>`
- les noms d'affichage des membres sont recherches par nom/slug uniquement lorsque `channels.discord.dangerouslyAllowNameMatching: true`
- les recherches utilisent l'identifiant de message original et sont contraintes par fenetre temporelle
- si la recherche echoue, les messages proxies sont traites comme des messages de bot et ignores sauf si `allowBots=true`

Les mises a jour de presence s'appliquent lorsque vous definissez un statut ou un champ d'activite, ou lorsque vous activez la presence automatique.

Exemple de statut seul :

{
  channels: {
    discord: {
      status: "idle",
    },
  },
}

Exemple d'activite (le statut personnalise est le type d'activite par defaut) :

{
  channels: {
    discord: {
      activity: "Focus time",
      activityType: 4,
    },
  },
}

Exemple de streaming :

{
  channels: {
    discord: {
      activity: "Live coding",
      activityType: 1,
      activityUrl: "https://twitch.tv/openclaw",
    },
  },
}

Correspondance des types d'activite :

- 0 : Playing
- 1 : Streaming (necessite `activityUrl`)
- 2 : Listening
- 3 : Watching
- 4 : Custom (utilise le texte d'activite comme etat ; l'emoji est optionnel)
- 5 : Competing

Exemple de presence automatique (signal de sante a l'execution) :

{
  channels: {
    discord: {
      autoPresence: {
        enabled: true,
        intervalMs: 30000,
        minUpdateIntervalMs: 15000,
        exhaustedText: "token exhausted",
      },
    },
  },
}

La presence automatique associe la disponibilite a l'execution au statut Discord : sain => online, degrade ou inconnu => idle, epuise ou indisponible => dnd. Textes optionnels de remplacement :

- `autoPresence.healthyText`
- `autoPresence.degradedText`
- `autoPresence.exhaustedText` (prend en charge le placeholder `{reason}`)

Discord prend en charge les approbations d'execution par bouton dans les DMs et peut optionnellement publier les invites d'approbation dans le salon d'origine.

Chemin de configuration :

- `channels.discord.execApprovals.enabled`
- `channels.discord.execApprovals.approvers`
- `channels.discord.execApprovals.target` (`dm` | `channel` | `both`, par defaut : `dm`)
- `agentFilter`, `sessionFilter`, `cleanupAfterResolve`

Lorsque `target` est `channel` ou `both`, l'invite d'approbation est visible dans le salon. Seuls les approbateurs configures peuvent utiliser les boutons ; les autres utilisateurs recoivent un refus ephemere. Les invites d'approbation incluent le texte de la commande, donc n'activez la livraison par salon que dans des salons de confiance. Si l'identifiant du salon ne peut pas etre derive de la cle de session, OpenClaw se replie sur la livraison par DM.

L'authentification gateway pour ce gestionnaire utilise le meme contrat de resolution d'identifiants partage que les autres clients Gateway :

- authentification locale env-first (`OPENCLAW_GATEWAY_TOKEN` / `OPENCLAW_GATEWAY_PASSWORD` puis `gateway.auth.*`)
- en mode local, `gateway.remote.*` peut etre utilise comme secours uniquement lorsque `gateway.auth.*` n'est pas defini ; les SecretRefs locaux configures mais non resolus echouent de maniere fermee
- support du mode distant via `gateway.remote.*` le cas echeant
- les remplacements d'URL sont securises : les remplacements CLI ne reutilisent pas les identifiants implicites, et les remplacements env utilisent uniquement les identifiants env

Si les approbations echouent avec des identifiants d'approbation inconnus, verifiez la liste des approbateurs et l'activation de la fonctionnalite.

Documentation associee : [Approbations d'execution](/docs/tools/exec-approvals)

Outils et controle d’acces aux actions

Les actions de message Discord incluent la messagerie, l’administration de salons, la moderation, la presence et les actions de metadonnees.

Exemples principaux :

• messagerie : sendMessage, readMessages, editMessage, deleteMessage, threadReply
• reactions : react, reactions, emojiList
• moderation : timeout, kick, ban
• presence : setPresence

Les controles d’acces aux actions se trouvent sous channels.discord.actions.*.

Comportement par defaut des controles :

Interface composants v2

OpenClaw utilise les composants v2 Discord pour les approbations d’execution et les marqueurs inter-contextes. Les actions de message Discord peuvent aussi accepter des components pour des interfaces personnalisees (avance ; necessite des instances de composants Carbon), tandis que les embeds anciens restent disponibles mais ne sont pas recommandes.

• channels.discord.ui.components.accentColor definit la couleur d’accentuation utilisee par les conteneurs de composants Discord (hex).
• Definissez par compte avec channels.discord.accounts.<id>.ui.components.accentColor.
• Les embeds sont ignores lorsque les composants v2 sont presents.

Exemple :

{
  channels: {
    discord: {
      ui: {
        components: {
          accentColor: "#5865F2",
        },
      },
    },
  },
}

Salons vocaux

OpenClaw peut rejoindre les salons vocaux Discord pour des conversations en temps reel et continues. Ceci est distinct des pieces jointes de messages vocaux.

Prerequis :

• Activez les commandes natives (commands.native ou channels.discord.commands.native).
• Configurez channels.discord.voice.
• Le bot a besoin des permissions Connect + Speak dans le salon vocal cible.

Utilisez la commande native Discord /vc join|leave|status pour controler les sessions. La commande utilise l’agent par defaut du compte et suit les memes regles de liste d’autorisation et de politique de groupe que les autres commandes Discord.

Exemple de connexion automatique :

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        autoJoin: [
          {
            guildId: "123456789012345678",
            channelId: "234567890123456789",
          },
        ],
        daveEncryption: true,
        decryptionFailureTolerance: 24,
        tts: {
          provider: "openai",
          openai: { voice: "alloy" },
        },
      },
    },
  },
}

Remarques :

• voice.tts remplace messages.tts pour la lecture vocale uniquement.
• Les tours de transcription vocale derivent le statut proprietaire de allowFrom Discord (ou dm.allowFrom) ; les interlocuteurs non proprietaires ne peuvent pas acceder aux outils reserves aux proprietaires (par exemple gateway et cron).
• Le vocal est active par defaut ; definissez channels.discord.voice.enabled=false pour le desactiver.
• voice.daveEncryption et voice.decryptionFailureTolerance sont transmis aux options de connexion @discordjs/voice.
• Les valeurs par defaut de @discordjs/voice sont daveEncryption=true et decryptionFailureTolerance=24 si non definis.
• OpenClaw surveille egalement les echecs de dechiffrement en reception et recupere automatiquement en quittant/rejoignant le salon vocal apres des echecs repetes dans une courte fenetre.
• Si les logs de reception affichent de maniere repetee DecryptionFailed(UnencryptedWhenPassthroughDisabled), il peut s’agir du bug amont de reception @discordjs/voice suivi dans discord.js #11419.

Messages vocaux

Les messages vocaux Discord affichent un apercu en forme d’onde et necessitent un audio OGG/Opus plus des metadonnees. OpenClaw genere la forme d’onde automatiquement, mais il a besoin de ffmpeg et ffprobe disponibles sur l’hote de la gateway pour inspecter et convertir les fichiers audio.

Prerequis et contraintes :

• Fournissez un chemin de fichier local (les URLs sont rejetees).
• Omettez le contenu texte (Discord n’autorise pas texte + message vocal dans le meme payload).
• Tout format audio est accepte ; OpenClaw convertit en OGG/Opus si necessaire.

Exemple :

message(action="send", channel="discord", target="channel:123", path="/path/to/audio.mp3", asVoice=true)

Depannage

- activez le Message Content Intent
- activez le Server Members Intent si vous dependez de la resolution utilisateur/membre
- redemarrez la gateway apres avoir modifie les intents

- verifiez `groupPolicy`
- verifiez la liste d'autorisation du serveur sous `channels.discord.guilds`
- si un bloc `channels` existe dans le serveur, seuls les salons listes sont autorises
- verifiez le comportement de `requireMention` et les motifs de mention

Commandes utiles :

openclaw doctor
openclaw channels status --probe
openclaw logs --follow

Causes courantes :

- `groupPolicy="allowlist"` sans liste d'autorisation serveur/salon correspondante
- `requireMention` configure au mauvais endroit (doit etre sous `channels.discord.guilds` ou l'entree du salon)
- expediteur bloque par la liste d'autorisation `users` du serveur/salon

Logs typiques :

- `Listener DiscordMessageListener timed out after 30000ms for event MESSAGE_CREATE`
- `Slow listener detected ...`
- `discord inbound worker timed out after ...`

Parametre de budget du listener :

- mono-compte : `channels.discord.eventQueue.listenerTimeout`
- multi-comptes : `channels.discord.accounts.<accountId>.eventQueue.listenerTimeout`

Parametre de timeout d'execution du worker :

- mono-compte : `channels.discord.inboundWorker.runTimeoutMs`
- multi-comptes : `channels.discord.accounts.<accountId>.inboundWorker.runTimeoutMs`
- par defaut : `1800000` (30 minutes) ; definissez `0` pour desactiver

Base recommandee :

{
  channels: {
    discord: {
      accounts: {
        default: {
          eventQueue: {
            listenerTimeout: 120000,
          },
          inboundWorker: {
            runTimeoutMs: 1800000,
          },
        },
      },
    },
  },
}

Utilisez `eventQueue.listenerTimeout` pour la configuration du listener lent et `inboundWorker.runTimeoutMs` uniquement si vous souhaitez une soupape de securite separee pour les tours d'agent en file d'attente.

Les verifications de permissions de `channels status --probe` ne fonctionnent que pour les identifiants numeriques de salon.

Si vous utilisez des cles par slug, la correspondance a l'execution peut fonctionner, mais la sonde ne peut pas verifier pleinement les permissions.

- DM desactive : `channels.discord.dm.enabled=false`
- Politique DM desactivee : `channels.discord.dmPolicy="disabled"` (ancien : `channels.discord.dm.policy`)
- en attente d'approbation d'appairage en mode `pairing`

Par defaut, les messages ecrits par des bots sont ignores.

Si vous definissez `channels.discord.allowBots=true`, utilisez des regles strictes de mention et de liste d'autorisation pour eviter les boucles.
Preferez `channels.discord.allowBots="mentions"` pour n'accepter que les messages de bot qui mentionnent le bot.

- gardez OpenClaw a jour (`openclaw update`) pour disposer de la logique de recuperation vocale Discord
- confirmez `channels.discord.voice.daveEncryption=true` (par defaut)
- commencez avec `channels.discord.voice.decryptionFailureTolerance=24` (valeur par defaut amont) et n'ajustez que si necessaire
- surveillez les logs pour :
  - `discord voice: DAVE decrypt failures detected`
  - `discord voice: repeated decrypt failures; attempting rejoin`
- si les echecs persistent apres la reconnexion automatique, collectez les logs et comparez avec [discord.js #11419](https://github.com/discordjs/discord.js/issues/11419)

Pointeurs vers la reference de configuration

Reference principale :

• Reference de configuration - Discord

Champs Discord a fort impact :

• demarrage/auth : enabled, token, accounts.*, allowBots
• politique : groupPolicy, dm.*, guilds.*, guilds.*.channels.*
• commande : commands.native, commands.useAccessGroups, configWrites, slashCommand.*
• file d’evenements : eventQueue.listenerTimeout (budget listener), eventQueue.maxQueueSize, eventQueue.maxConcurrency
• worker entrant : inboundWorker.runTimeoutMs
• reponse/historique : replyToMode, historyLimit, dmHistoryLimit, dms.*.historyLimit
• livraison : textChunkLimit, chunkMode, maxLinesPerMessage
• streaming : streaming (alias ancien : streamMode), draftChunk, blockStreaming, blockStreamingCoalesce
• media/reessai : mediaMaxMb, retry
  • mediaMaxMb plafonne les uploads sortants Discord (par defaut : 8MB)
• actions : actions.*
• presence : activity, status, activityType, activityUrl
• interface : ui.components.accentColor
• fonctionnalites : threadBindings, bindings[] au niveau racine (type: "acp"), pluralkit, execApprovals, intents, agentComponents, heartbeat, responsePrefix

Securite et operations

• Traitez les tokens de bot comme des secrets (DISCORD_BOT_TOKEN prefere dans les environnements supervises).
• Accordez le minimum de permissions Discord necessaires.
• Si le deploiement/etat des commandes est obsolete, redemarrez la gateway et reverifiez avec openclaw channels status --probe.

Liens associes

• Appairage
• Routage de canaux
• Routage multi-agents
• Depannage
• Commandes slash