Slack

Statut : pret pour la production pour les DMs + salons via les integrations d’applications Slack. Le mode par defaut est Socket Mode ; le mode API Events HTTP est egalement pris en charge.

• Appairage — Les DMs Slack 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

Socket Mode (par defaut)

  ### Etape 1 : creer l'application Slack et les tokens
    Dans les parametres de l'application Slack :

    - activez **Socket Mode**
    - creez un **App Token** (`xapp-...`) avec `connections:write`
    - installez l'application et copiez le **Bot Token** (`xoxb-...`)


  ### Etape 2 : configurer OpenClaw

{
  channels: {
    slack: {
      enabled: true,
      mode: "socket",
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}

    Variable d'environnement de secours (compte par defaut uniquement) :

SLACK_APP_TOKEN=xapp-...
SLACK_BOT_TOKEN=xoxb-...

  ### Etape 3 : abonner les evenements de l'application
    Abonnez les evenements bot pour :

    - `app_mention`
    - `message.channels`, `message.groups`, `message.im`, `message.mpim`
    - `reaction_added`, `reaction_removed`
    - `member_joined_channel`, `member_left_channel`
    - `channel_rename`
    - `pin_added`, `pin_removed`

    Activez egalement l'**onglet Messages** du App Home pour les DMs.


  ### Etape 4 : demarrer la gateway

openclaw gateway

Mode API Events HTTP

  ### Etape 1 : configurer l'application Slack pour HTTP

    - definissez le mode sur HTTP (`channels.slack.mode="http"`)
    - copiez le **Signing Secret** Slack
    - definissez l'URL de requete des Event Subscriptions + Interactivite + commande Slash sur le meme chemin webhook (par defaut `/slack/events`)



  ### Etape 2 : configurer le mode HTTP OpenClaw

{
  channels: {
    slack: {
      enabled: true,
      mode: "http",
      botToken: "xoxb-...",
      signingSecret: "your-signing-secret",
      webhookPath: "/slack/events",
    },
  },
}

  ### Etape 3 : utiliser des chemins webhook uniques pour le HTTP multi-comptes
    Le mode HTTP par compte est pris en charge.

    Donnez a chaque compte un `webhookPath` distinct pour eviter les collisions d'enregistrement.

Modele de tokens

• botToken + appToken sont requis pour le Socket Mode.
• Le mode HTTP necessite botToken + signingSecret.
• Les tokens de configuration ont priorite sur la variable d’environnement de secours.
• SLACK_BOT_TOKEN / SLACK_APP_TOKEN ne s’appliquent qu’au compte par defaut.
• userToken (xoxp-...) est configurable uniquement par fichier (pas de variable d’environnement) et en lecture seule par defaut (userTokenReadOnly: true).
• Optionnel : ajoutez chat:write.customize si vous souhaitez que les messages sortants utilisent l’identite de l’agent actif (nom d’utilisateur et icone personnalises). icon_emoji utilise la syntaxe :emoji_name:.

Astuce : Pour les actions/lectures de repertoire, le token utilisateur peut etre prefere lorsqu’il est configure. Pour les ecritures, le token bot reste prefere ; les ecritures par token utilisateur ne sont autorisees que lorsque userTokenReadOnly: false et que le token bot est indisponible.

Controle d’acces et routage

Politique DM

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

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

Options DM :

- `dm.enabled` (par defaut true)
- `channels.slack.allowFrom` (prefere)
- `dm.allowFrom` (ancien)
- `dm.groupEnabled` (DMs de groupe par defaut false)
- `dm.groupChannels` (liste d'autorisation MPIM optionnelle)

Priorite multi-comptes :

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

L'appairage en DM utilise `openclaw pairing approve slack <code>`.

Politique de salon

`channels.slack.groupPolicy` controle la gestion des salons :

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

La liste d'autorisation des salons se trouve sous `channels.slack.channels` et doit utiliser des identifiants de salon stables.

Note d'execution : si `channels.slack` est completement absent (configuration par env uniquement), l'execution se replie sur `groupPolicy="allowlist"` et journalise un avertissement (meme si `channels.defaults.groupPolicy` est defini).

Resolution nom/identifiant :

- les entrees de liste d'autorisation de salon et de DM sont resolues au demarrage lorsque l'acces par token le permet
- les entrees de nom de salon non resolues sont conservees telles quelles mais ignorees pour le routage par defaut
- l'autorisation entrante et le routage de salon sont d'abord par identifiant ; la correspondance directe par nom d'utilisateur/slug necessite `channels.slack.dangerouslyAllowNameMatching: true`

Mentions et utilisateurs de salon

Les messages de salon sont filtres par mention par defaut.

Sources de mention :

- mention explicite de l'application (`<@botId>`)
- motifs de mention regex (`agents.list[].groupChat.mentionPatterns`, secours `messages.groupChat.mentionPatterns`)
- comportement implicite de reponse au bot dans un fil

Controles par salon (`channels.slack.channels.<id>` ; noms uniquement via resolution au demarrage ou `dangerouslyAllowNameMatching`) :

- `requireMention`
- `users` (liste d'autorisation)
- `allowBots`
- `skills`
- `systemPrompt`
- `tools`, `toolsBySender`
- Format des cles `toolsBySender` : `id:`, `e164:`, `username:`, `name:`, ou joker `"*"`
  (les cles anciennes sans prefixe correspondent uniquement a `id:`)

Commandes et comportement slash

• Le mode commande native automatique est desactive pour Slack (commands.native: "auto" n’active pas les commandes natives Slack).
• Activez les gestionnaires de commandes natives Slack avec channels.slack.commands.native: true (ou global commands.native: true).
• Lorsque les commandes natives sont activees, enregistrez les commandes slash correspondantes dans Slack (/<command>), avec une exception :
  • enregistrez /agentstatus pour la commande status (Slack reserve /status)
• Si les commandes natives ne sont pas activees, vous pouvez executer une seule commande slash configuree via channels.slack.slashCommand.
• Les menus d’arguments natifs adaptent leur strategie de rendu :
  • jusqu’a 5 options : blocs de boutons
  • 6-100 options : menu de selection statique
  • plus de 100 options : selection externe avec filtrage asynchrone des options lorsque les gestionnaires d’options d’interactivite sont disponibles
  • si les valeurs d’options encodees depassent les limites Slack, le flux se replie sur les boutons
• Pour les payloads d’options longs, les menus d’arguments de commande slash utilisent une boite de dialogue de confirmation avant d’envoyer la valeur selectionnee.

Reponses interactives

Slack peut afficher des controles de reponse interactifs rediges par l’agent, mais cette fonctionnalite est desactivee par defaut.

Activation globale :

{
  channels: {
    slack: {
      capabilities: {
        interactiveReplies: true,
      },
    },
  },
}

Ou activation pour un seul compte Slack :

{
  channels: {
    slack: {
      accounts: {
        ops: {
          capabilities: {
            interactiveReplies: true,
          },
        },
      },
    },
  },
}

Lorsque cette fonctionnalite est activee, les agents peuvent emettre des directives specifiques a Slack :

• [[slack_buttons: Approve:approve, Reject:reject]]
• [[slack_select: Choose a target | Canary:canary, Production:production]]

Ces directives sont compilees en Slack Block Kit et les clics ou selections sont routes via le chemin d’evenement d’interaction Slack existant.

Remarques :

• Il s’agit d’une interface specifique a Slack. Les autres canaux ne traduisent pas les directives Block Kit Slack dans leurs propres systemes de boutons.
• Les valeurs de callback interactif sont des tokens opaques generes par OpenClaw, pas les valeurs brutes redigees par l’agent.
• Si les blocs interactifs generes depassent les limites Block Kit Slack, OpenClaw se replie sur la reponse en texte original au lieu d’envoyer un payload de blocs invalide.

Parametres par defaut des commandes slash :

• enabled: false
• name: "openclaw"
• sessionPrefix: "slack:slash"
• ephemeral: true

Les sessions slash utilisent des cles isolees :

• agent:<agentId>:slack:slash:<userId>

et routent toujours l’execution de commande vers la session de conversation cible (CommandTargetSessionKey).

Fils, sessions et tags de reponse

• Les DMs sont routes comme direct ; les salons comme channel ; les MPIMs comme group.
• Avec le session.dmScope=main par defaut, les DMs Slack se regroupent dans la session principale de l’agent.
• Sessions de salon : agent:<agentId>:slack:channel:<channelId>.
• Les reponses de fil peuvent creer des suffixes de session de fil (:thread:<threadTs>) le cas echeant.
• channels.slack.thread.historyScope par defaut est thread ; thread.inheritParent par defaut est false.
• channels.slack.thread.initialHistoryLimit controle le nombre de messages de fil existants recuperes au demarrage d’une nouvelle session de fil (par defaut 20 ; definissez 0 pour desactiver).

Controles de fils de reponse :

• channels.slack.replyToMode : off|first|all (par defaut off)
• channels.slack.replyToModeByChatType : par direct|group|channel
• secours ancien pour les chats directs : channels.slack.dm.replyToMode

Les tags de reponse manuels sont pris en charge :

• [[reply_to_current]]
• [[reply_to:<id>]]

Remarque : replyToMode="off" desactive tous les fils de reponse dans Slack, y compris les tags explicites [[reply_to_*]]. Ceci differe de Telegram, ou les tags explicites sont toujours honores en mode "off". La difference reflete les modeles de fil des plateformes : les fils Slack masquent les messages du salon, tandis que les reponses Telegram restent visibles dans le flux principal du chat.

Medias, decoupage et livraison

Les pieces jointes de fichiers Slack sont telechargees depuis les URLs privees hebergees par Slack (requete authentifiee par token) et ecrites dans le stockage media lorsque le telechargement reussit et que les limites de taille le permettent.

La limite de taille entrante a l'execution est par defaut de `20 Mo` sauf remplacement par `channels.slack.mediaMaxMb`.

- les morceaux de texte utilisent `channels.slack.textChunkLimit` (par defaut 4000)
- `channels.slack.chunkMode="newline"` active le decoupage par paragraphe en priorite
- les envois de fichiers utilisent les API d'upload Slack et peuvent inclure des reponses de fil (`thread_ts`)
- la limite media sortante suit `channels.slack.mediaMaxMb` lorsqu'elle est configuree ; sinon les envois de canal utilisent les valeurs par defaut du type MIME du pipeline media

Cibles explicites preferees :

- `user:<id>` pour les DMs
- `channel:<id>` pour les salons

Les DMs Slack sont ouverts via les API de conversation Slack lors de l'envoi a des cibles utilisateur.

Actions et controles

Les actions Slack sont controlees par channels.slack.actions.*.

Groupes d’actions disponibles dans l’outillage Slack actuel :

Evenements et comportement operationnel

• Les modifications/suppressions/diffusions de fil de messages sont transformes en evenements systeme.
• Les evenements d’ajout/suppression de reaction sont transformes en evenements systeme.
• Les evenements d’arrivee/depart de membre, de creation/renommage de salon et d’ajout/suppression d’epingle sont transformes en evenements systeme.
• Les mises a jour de statut des fils d’assistant (pour les indicateurs « est en train d’ecrire… » dans les fils) utilisent assistant.threads.setStatus et necessitent le scope bot assistant:write.
• channel_id_changed peut migrer les cles de configuration de salon lorsque configWrites est active.
• Les metadonnees de sujet/objectif de salon sont traitees comme contexte non fiable et peuvent etre injectees dans le contexte de routage.
• Les actions de blocs et interactions modales emettent des evenements systeme structures Slack interaction: ... avec des champs de payload riches :
  • actions de blocs : valeurs selectionnees, libelles, valeurs de selecteur et metadonnees workflow_*
  • evenements view_submission et view_closed modaux avec les metadonnees du salon route et les saisies de formulaire

Reactions d’accuse de reception

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

Ordre de resolution :

• channels.slack.accounts.<accountId>.ackReaction
• channels.slack.ackReaction
• messages.ackReaction
• emoji de secours de l’identite de l’agent (agents.list[].identity.emoji, sinon “eyes”)

Remarques :

• Slack attend des shortcodes (par exemple "eyes").
• Utilisez "" pour desactiver la reaction pour le compte Slack ou globalement.

Reaction de saisie de secours

typingReaction ajoute une reaction temporaire au message Slack entrant pendant qu’OpenClaw traite une reponse, puis la supprime lorsque l’execution se termine. C’est un repli utile lorsque la saisie native de l’assistant Slack est indisponible, notamment en DM.

Ordre de resolution :

• channels.slack.accounts.<accountId>.typingReaction
• channels.slack.typingReaction

Remarques :

• Slack attend des shortcodes (par exemple "hourglass_flowing_sand").
• La reaction est en best-effort et le nettoyage est tente automatiquement apres la reponse ou le chemin d’erreur.

Manifeste et checklist de scopes

{
  "display_information": {
    "name": "OpenClaw",
    "description": "Slack connector for OpenClaw"
  },
  "features": {
    "bot_user": {
      "display_name": "OpenClaw",
      "always_online": false
    },
    "app_home": {
      "messages_tab_enabled": true,
      "messages_tab_read_only_enabled": false
    },
    "slash_commands": [
      {
        "command": "/openclaw",
        "description": "Send a message to OpenClaw",
        "should_escape": false
      }
    ]
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "chat:write",
        "channels:history",
        "channels:read",
        "groups:history",
        "im:history",
        "im:read",
        "im:write",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "users:read",
        "app_mentions:read",
        "assistant:write",
        "reactions:read",
        "reactions:write",
        "pins:read",
        "pins:write",
        "emoji:read",
        "commands",
        "files:read",
        "files:write"
      ]
    }
  },
  "settings": {
    "socket_mode_enabled": true,
    "event_subscriptions": {
      "bot_events": [
        "app_mention",
        "message.channels",
        "message.groups",
        "message.im",
        "message.mpim",
        "reaction_added",
        "reaction_removed",
        "member_joined_channel",
        "member_left_channel",
        "channel_rename",
        "pin_added",
        "pin_removed"
      ]
    }
  }
}

Si vous configurez `channels.slack.userToken`, les scopes de lecture typiques sont :

- `channels:history`, `groups:history`, `im:history`, `mpim:history`
- `channels:read`, `groups:read`, `im:read`, `mpim:read`
- `users:read`
- `reactions:read`
- `pins:read`
- `emoji:read`
- `search:read` (si vous dependez des lectures de recherche Slack)

Depannage

Verifiez, dans l'ordre :

- `groupPolicy`
- liste d'autorisation des salons (`channels.slack.channels`)
- `requireMention`
- liste d'autorisation `users` par salon

Commandes utiles :

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

Verifiez :

- `channels.slack.dm.enabled`
- `channels.slack.dmPolicy` (ou ancien `channels.slack.dm.policy`)
- approbations d'appairage / entrees de liste d'autorisation

openclaw pairing list slack

Validez les tokens bot + app et l'activation du Socket Mode dans les parametres de l'application Slack.

Validez :

- signing secret
- chemin webhook
- URLs de requete Slack (Events + Interactivite + commandes Slash)
- `webhookPath` unique par compte HTTP

Verifiez si vous souhaitiez :

- le mode commande native (`channels.slack.commands.native: true`) avec des commandes slash correspondantes enregistrees dans Slack
- ou le mode commande slash unique (`channels.slack.slashCommand.enabled: true`)

Verifiez aussi `commands.useAccessGroups` et les listes d'autorisation salon/utilisateur.

Streaming texte

OpenClaw prend en charge le streaming texte natif Slack via l’API Agents and AI Apps.

channels.slack.streaming controle le comportement d’apercu en direct :

• off : desactiver le streaming d’apercu en direct.
• partial (par defaut) : remplacer le texte d’apercu par la derniere sortie partielle.
• block : ajouter des mises a jour d’apercu par morceaux.
• progress : afficher un texte de statut de progression pendant la generation, puis envoyer le texte final.

channels.slack.nativeStreaming controle l’API de streaming native de Slack (chat.startStream / chat.appendStream / chat.stopStream) lorsque streaming est partial (par defaut : true).

Desactiver le streaming natif Slack (conserver le comportement d’apercu brouillon) :

channels:
  slack:
    streaming: partial
    nativeStreaming: false

Cles anciennes :

• channels.slack.streamMode (replace | status_final | append) est migre automatiquement vers channels.slack.streaming.
• La valeur booleenne channels.slack.streaming est migree automatiquement vers channels.slack.nativeStreaming.

Prerequis

1. Activez Agents and AI Apps dans les parametres de votre application Slack.
2. Assurez-vous que l’application a le scope assistant:write.
3. Un fil de reponse doit etre disponible pour ce message. La selection du fil suit toujours replyToMode.

Comportement

• Le premier morceau de texte demarre un flux (chat.startStream).
• Les morceaux suivants sont ajoutes au meme flux (chat.appendStream).
• La fin de la reponse finalise le flux (chat.stopStream).
• Les medias et payloads non textuels se replient sur la livraison normale.
• Si le streaming echoue en cours de reponse, OpenClaw se replie sur la livraison normale pour les payloads restants.

Pointeurs vers la reference de configuration

Reference principale :

• Reference de configuration - Slack

  Champs Slack a fort impact :

  • mode/auth : mode, botToken, appToken, signingSecret, webhookPath, accounts.*
  • acces DM : dm.enabled, dmPolicy, allowFrom (ancien : dm.policy, dm.allowFrom), dm.groupEnabled, dm.groupChannels
  • bascule de compatibilite : dangerouslyAllowNameMatching (derogatoire ; gardez desactive sauf si necessaire)
  • acces salon : groupPolicy, channels.*, channels.*.users, channels.*.requireMention
  • fils/historique : replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
  • livraison : textChunkLimit, chunkMode, mediaMaxMb, streaming, nativeStreaming
  • ops/fonctionnalites : configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

Liens associes

• Appairage
• Routage de canaux
• Depannage
• Configuration
• Commandes slash