Passer au contenu principal

​
Slack

​
Mode socket (par defaut)

​
Demarrage rapide (debutant)

  1. Creez une application Slack et activez le Mode socket.
  2. Creez un App Token (xapp-...) et un Bot Token (xoxb-...).
  3. Definissez les tokens pour OpenClaw et demarrez la Gateway (passerelle).
Configuration minimale : 
{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}

​
Configuration

  1. Creez une application Slack (From scratch) sur https://api.slack.com/apps.
  2. Mode socket → activez l’option. Puis allez dans Basic Information → App-Level Tokens → Generate Token and Scopes avec le scope connections:write. Copiez l’App Token (xapp-...).
  3. OAuth & Permissions → ajoutez les scopes du bot (utilisez le manifeste ci-dessous). Cliquez sur Install to Workspace. Copiez le Bot User OAuth Token (xoxb-...).
  4. Optionnel : OAuth & Permissions → ajoutez des User Token Scopes (voir la liste en lecture seule ci-dessous). Reinstallez l’application et copiez le User OAuth Token (xoxp-...).
  5. Event Subscriptions → activez les evenements et abonnez-vous a :
    • message.* (inclut les editions/suppressions/diffusions de fils)
    • app_mention
    • reaction_added, reaction_removed
    • member_joined_channel, member_left_channel
    • channel_rename
    • pin_added, pin_removed
  6. Invitez le bot dans les canaux que vous souhaitez qu’il lise.
  7. Slash Commands → creez /openclaw si vous utilisez channels.slack.slashCommand. Si vous activez les commandes natives, ajoutez une commande slash par commande integree (memes noms que /help). Par defaut, le mode natif est desactive pour Slack, sauf si vous definissez channels.slack.commands.native: true (la valeur globale commands.native est "auto", ce qui laisse Slack desactive).
  8. App Home → activez l’onglet Messages afin que les utilisateurs puissent envoyer des Messages prives au bot.
Utilisez le manifeste ci-dessous pour que les scopes et les evenements restent synchronises. Prise en charge multi-comptes : utilisez channels.slack.accounts avec des tokens par compte et name en option. Voir gateway/configuration pour le modele partage.

​
Configuration OpenClaw (minimale)

Definissez les tokens via des variables d’environnement (recommande) :
  • SLACK_APP_TOKEN=xapp-...
  • SLACK_BOT_TOKEN=xoxb-...
Ou via la configuration : 
{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}

​
Token utilisateur (optionnel)

OpenClaw peut utiliser un token utilisateur Slack (xoxp-...) pour les operations de lecture (historique, epingles, reactions, emoji, informations de membres). Par defaut, cela reste en lecture seule : les lectures preferent le token utilisateur lorsqu’il est present, et les ecritures utilisent toujours le token du bot sauf si vous y consentez explicitement. Meme avec userTokenReadOnly: false, le token du bot reste prefere pour les ecritures lorsqu’il est disponible. Les tokens utilisateur sont configures dans le fichier de configuration (pas de prise en charge par variables d’environnement). Pour le multi-comptes, definissez channels.slack.accounts.<id>.userToken. Exemple avec tokens bot + app + utilisateur : 
{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
      userToken: "xoxp-...",
    },
  },
}
Exemple avec userTokenReadOnly defini explicitement (autoriser les ecritures via le token utilisateur) : 
{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
      userToken: "xoxp-...",
      userTokenReadOnly: false,
    },
  },
}

​
Utilisation des tokens

  • Operations de lecture (historique, liste des reactions, liste des epingles, liste des emoji, informations des membres, recherche) : preference pour le token utilisateur lorsqu’il est configure, sinon le token du bot.
  • Operations d’ecriture (envoyer/editer/supprimer des messages, ajouter/supprimer des reactions, epingler/desepingler, televersements de fichiers) : utilisent le token du bot par defaut. Si userTokenReadOnly: false et qu’aucun token de bot n’est disponible, OpenClaw bascule vers le token utilisateur.

​
Contexte d’historique

  • channels.slack.historyLimit (ou channels.slack.accounts.*.historyLimit) controle le nombre de messages recents de canal/groupe integres dans le prompt.
  • Repli sur messages.groupChat.historyLimit. Definissez 0 pour desactiver (par defaut 50).

​
Mode HTTP (API Events)

Utilisez le mode webhook HTTP lorsque votre Gateway (passerelle) est accessible par Slack via HTTPS (typique pour des deploiements serveur). Le mode HTTP utilise l’API Events + Interactivity + Slash Commands avec une URL de requete partagee.

​
Configuration (mode HTTP)

  1. Creez une application Slack et desactivez le Mode socket (optionnel si vous n’utilisez que HTTP).
  2. Basic Information → copiez le Signing Secret.
  3. OAuth & Permissions → installez l’application et copiez le Bot User OAuth Token (xoxb-...).
  4. Event Subscriptions → activez les evenements et definissez l’URL de requete vers le chemin webhook de votre gateway (par defaut /slack/events).
  5. Interactivity & Shortcuts → activez et definissez la meme URL de requete.
  6. Slash Commands → definissez la meme URL de requete pour vos commande(s).
Exemple d’URL de requete : https://gateway-host/slack/events

​
Configuration OpenClaw (minimale)

{
  channels: {
    slack: {
      enabled: true,
      mode: "http",
      botToken: "xoxb-...",
      signingSecret: "your-signing-secret",
      webhookPath: "/slack/events",
    },
  },
}
Mode HTTP multi-comptes : definissez channels.slack.accounts.<id>.mode = "http" et fournissez un webhookPath unique par compte afin que chaque application Slack pointe vers sa propre URL.

​
Manifeste (optionnel)

Utilisez ce manifeste d’application Slack pour creer l’application rapidement (ajustez le nom/la commande si vous le souhaitez). Incluez les scopes utilisateur si vous prevoyez de configurer un token utilisateur. 
{
  "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",
        "groups:read",
        "groups:write",
        "im:history",
        "im:read",
        "im:write",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "users:read",
        "app_mentions:read",
        "reactions:read",
        "reactions:write",
        "pins:read",
        "pins:write",
        "emoji:read",
        "commands",
        "files:read",
        "files:write"
      ],
      "user": [
        "channels:history",
        "channels:read",
        "groups:history",
        "groups:read",
        "im:history",
        "im:read",
        "mpim:history",
        "mpim:read",
        "users:read",
        "reactions:read",
        "pins:read",
        "emoji:read",
        "search:read"
      ]
    }
  },
  "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 activez les commandes natives, ajoutez une entree slash_commands par commande que vous souhaitez exposer (correspondant a la liste /help). Surchargez avec channels.slack.commands.native.

​
Scopes (actuels vs optionnels)

L’API Conversations de Slack est scopee par type : vous n’avez besoin que des scopes pour les types de conversations que vous utilisez reellement (channels, groups, im, mpim). Voir https://docs.slack.dev/apis/web-api/using-the-conversations-api/ pour la vue d’ensemble.

​
Scopes du token du bot (requis)

​
Scopes du token utilisateur (optionnels, lecture seule par defaut)

Ajoutez-les sous User Token Scopes si vous configurez channels.slack.userToken.
  • 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

​
Non requis aujourd’hui (mais probables a l’avenir)

  • mpim:write (uniquement si nous ajoutons l’ouverture de group-DM / demarrage de DM via conversations.open)
  • groups:write (uniquement si nous ajoutons la gestion des canaux prives : creer/renommer/inviter/archiver)
  • chat:write.public (uniquement si nous voulons publier dans des canaux dont le bot ne fait pas partie) https://docs.slack.dev/reference/scopes/chat.write.public
  • users:read.email (uniquement si nous avons besoin des champs email depuis users.info) https://docs.slack.dev/changelog/2017-04-narrowing-email-access
  • files:read (uniquement si nous commencons a lister/lire les metadonnees de fichiers)

​
Configuration

Slack utilise uniquement le Mode socket (pas de serveur webhook HTTP). Fournissez les deux tokens : 
{
  "slack": {
    "enabled": true,
    "botToken": "xoxb-...",
    "appToken": "xapp-...",
    "groupPolicy": "allowlist",
    "dm": {
      "enabled": true,
      "policy": "pairing",
      "allowFrom": ["U123", "U456", "*"],
      "groupEnabled": false,
      "groupChannels": ["G123"],
      "replyToMode": "all"
    },
    "channels": {
      "C123": { "allow": true, "requireMention": true },
      "#general": {
        "allow": true,
        "requireMention": true,
        "users": ["U123"],
        "skills": ["search", "docs"],
        "systemPrompt": "Keep answers short."
      }
    },
    "reactionNotifications": "own",
    "reactionAllowlist": ["U123"],
    "replyToMode": "off",
    "actions": {
      "reactions": true,
      "messages": true,
      "pins": true,
      "memberInfo": true,
      "emojiList": true
    },
    "slashCommand": {
      "enabled": true,
      "name": "openclaw",
      "sessionPrefix": "slack:slash",
      "ephemeral": true
    },
    "textChunkLimit": 4000,
    "mediaMaxMb": 20
  }
}
Les jetons peuvent également être fournis via des variables env :
  • SLACK_BOT_TOKEN
  • SLACK_APP_TOKEN
Les reactions d’accuse de reception sont controlees globalement via messages.ackReaction + messages.ackReactionScope. Utilisez messages.removeAckAfterReply pour effacer la reaction d’accuse de reception apres la reponse du bot.

​
Limites

  • Le texte sortant est fragmente a channels.slack.textChunkLimit (par defaut 4000).
  • Fragmentation optionnelle par retours a la ligne : definissez channels.slack.chunkMode="newline" pour scinder sur les lignes vides (limites de paragraphes) avant la fragmentation par longueur.
  • Les televersements de medias sont limites par channels.slack.mediaMaxMb (par defaut 20).

​
Fil de reponse

Par defaut, OpenClaw repond dans le canal principal. Utilisez channels.slack.replyToMode pour controler le fil automatique :
ModeComportement
offPar defaut. Repondre dans le canal principal. Ne creer un fil que si le message declencheur etait deja dans un fil.
firstLa premiere reponse va dans le fil (sous le message declencheur), les reponses suivantes vont dans le canal principal. Utile pour conserver le contexte sans encombrer les fils.
allToutes les reponses vont dans le fil. Garde les conversations contenues mais peut reduire la visibilite.
Le mode s’applique aux reponses automatiques et aux appels d’outils de l’agent (slack sendMessage).

​
Fil par type de discussion

Vous pouvez configurer un comportement de fil different par type de discussion en definissant channels.slack.replyToModeByChatType : 
{
  channels: {
    slack: {
      replyToMode: "off", // default for channels
      replyToModeByChatType: {
        direct: "all", // DMs always thread
        group: "first", // group DMs/MPIM thread first reply
      },
    },
  },
}
Types de discussion pris en charge :
  • direct : Messages prives 1:1 (Slack im)
  • group : Messages prives de groupe / MPIMs (Slack mpim)
  • channel : canaux standards (publics/prives)
Priorite :
  1. replyToModeByChatType.<chatType>
  2. replyToMode
  3. Fournisseur par défaut (off)
Le parametre historique channels.slack.dm.replyToMode est toujours accepte comme repli pour direct lorsqu’aucune surcharge par type de discussion n’est definie. Exemples : Sujet de discussion uniquement : 
{
  channels: {
    slack: {
      replyToMode: "off",
      replyToModeByChatType: { direct: "all" },
    },
  },
}
Fil pour les Messages prives de groupe mais canaux a la racine : 
{
  channels: {
    slack: {
      replyToMode: "off",
      replyToModeByChatType: { group: "first" },
    },
  },
}
Faire des fils de discussion, garder les MP à la racine : 
{
  channels: {
    slack: {
      replyToMode: "first",
      replyToModeByChatType: { direct: "off", group: "off" },
    },
  },
}

​
Balises de fil manuel

Pour un controle fin, utilisez ces balises dans les reponses de l’agent :
  • [[reply_to_current]] — repondre au message declencheur (demarrer/continuer un fil).
  • [[reply_to:<id>]] — repondre a un identifiant de message specifique.

​
Sessions + routage

  • Les Messages prives partagent la session main (comme WhatsApp/Telegram).
  • Les canaux correspondent a des sessions agent:<agentId>:slack:channel:<channelId>.
  • Les commandes slash utilisent des sessions agent:<agentId>:slack:slash:<userId> (prefixe configurable via channels.slack.slashCommand.sessionPrefix).
  • Si Slack ne fournit pas channel_type, OpenClaw l’infere a partir du prefixe d’ID de canal (D, C, G) et utilise par defaut channel afin de maintenir des cles de session stables.
  • L’enregistrement des commandes natives utilise commands.native (valeur globale par defaut "auto" → Slack desactive) et peut etre surcharge par espace de travail avec channels.slack.commands.native. Les commandes texte necessitent des messages /... autonomes et peuvent etre desactivees avec commands.text: false. Les commandes slash Slack sont gerees dans l’application Slack et ne sont pas supprimees automatiquement. Utilisez commands.useAccessGroups: false pour contourner les verifications de groupes d’acces pour les commandes.
  • Liste complete des commandes + configuration : Slash commands

​
Sécurité DM (jumelage)

  • Par defaut : channels.slack.dm.policy="pairing" — les expediteurs de Messages prives inconnus recoivent un code d’appairage (expire apres 1 heure).
  • Approbation via : openclaw pairing approve slack <code>.
  • Pour autoriser tout le monde : definissez channels.slack.dm.policy="open" et channels.slack.dm.allowFrom=["*"].
  • channels.slack.dm.allowFrom accepte des identifiants utilisateur, des @handles ou des emails (resolus au demarrage lorsque les tokens le permettent). L’assistant accepte les noms d’utilisateur et les resout en identifiants pendant la configuration lorsque les tokens le permettent.

​
Politique de groupe

  • channels.slack.groupPolicy controle la gestion des canaux (open|disabled|allowlist).
  • allowlist exige que les canaux soient listes dans channels.slack.channels.
  • Si vous ne definissez que SLACK_BOT_TOKEN/SLACK_APP_TOKEN et ne creez jamais de section channels.slack, les valeurs par defaut d’execution definissent groupPolicy sur open. Ajoutez channels.slack.groupPolicy, channels.defaults.groupPolicy, ou une liste d’autorisation de canaux pour verrouiller.
  • L’assistant de configuration accepte les noms #channel et les resout en identifiants lorsque possible (publics + prives) ; s’il existe plusieurs correspondances, il prefere le canal actif.
  • Au demarrage, OpenClaw resout les noms de canaux/utilisateurs dans les listes d’autorisation en identifiants (lorsque les tokens le permettent) et journalise le mapping ; les entrees non resolues sont conservees telles quelles.
  • Pour n’autoriser aucun canal, definissez channels.slack.groupPolicy: "disabled" (ou conservez une liste d’autorisation vide).
Options de canal (channels.slack.channels.<id> ou channels.slack.channels.<name>) :
  • allow : autoriser/refuser le canal lorsque groupPolicy="allowlist".
  • requireMention : controle des mentions pour le canal.
  • tools : surcharges optionnelles de politique d’outils par canal (allow/deny/alsoAllow).
  • toolsBySender : surcharges optionnelles de politique d’outils par expediteur au sein du canal (cles = identifiants d’expediteur/@handles/emails ; joker "*" pris en charge).
  • allowBots : autoriser les messages rediges par le bot dans ce canal (par defaut : false).
  • users : liste d’autorisation utilisateur optionnelle par canal.
  • skills : filtre de Skills (omettre = toutes les Skills, vide = aucune).
  • systemPrompt : invite systeme supplementaire pour le canal (combinee avec le sujet/l’objectif).
  • enabled : definissez false pour desactiver le canal.

​
Cibles de livraison

Utilisez-les avec des envois cron/CLI :
  • user:<id> pour les Messages prives
  • channel:<id> pour les canaux

​
Actions d’outils

Les actions d’outils Slack peuvent etre controlees via channels.slack.actions.* :
Groupe d’actionsPar défautNotes
reactionsactiveReact + lister les reactions
messagesactiveLire/envoyer/editer/supprimer
pinsactiveEpingler/desepingler/lister
memberInfoactiveInformations de membres
emojiListactiveListe d’emoji personnalises

​
Notes de securite

  • Les ecritures utilisent par defaut le token du bot afin que les actions modifiant l’etat restent limitees aux permissions et a l’identite du bot de l’application.
  • Definir userTokenReadOnly: false permet d’utiliser le token utilisateur pour les operations d’ecriture lorsqu’aucun token de bot n’est disponible, ce qui signifie que les actions s’executent avec l’acces de l’utilisateur installateur. Traitez le token utilisateur comme hautement privilegie et maintenez des controles d’actions et des listes d’autorisation stricts.
  • Si vous activez les ecritures via token utilisateur, assurez-vous que le token utilisateur inclut les scopes d’ecriture attendus (chat:write, reactions:write, pins:write, files:write) sinon ces operations echoueront.

​
Problemes courants

Exécutez d’abord cette échelle : 
openclaw models auth paste-token --provider anthropic
openclaw models status
Ensuite, confirmez l’état d’appairage du DM si nécessaire: 
openclaw pairing list slack
Échecs communs :
  • Réponses connectées mais pas de canal : canal bloqué par groupPolicy ou non dans la liste de diffusion channels.slack.channels.
  • DMs ignorés: l’expéditeur n’est pas approuvé lorsque channels.slack.dm.policy="appairage".
  • Erreurs d’API (missing_scope, not_in_channel, échecs d’authentification): les tokens bot/app ou Slack sont incomplets.
channels/signal.md

​
Notes

  • Le controle des mentions est gere via channels.slack.channels (definissez requireMention sur true) ; agents.list[].groupChat.mentionPatterns (ou messages.groupChat.mentionPatterns) comptent egalement comme mentions.
  • Surcharge multi-agent : definissez des motifs par agent sur agents.list[].groupChat.mentionPatterns.
  • Les notifications de reactions suivent channels.slack.reactionNotifications (utilisez reactionAllowlist avec le mode allowlist).
  • Les messages rediges par le bot sont ignores par defaut ; activez via channels.slack.allowBots ou channels.slack.channels.<id>.allowBots.
  • Avertissement : si vous autorisez les reponses a d’autres bots (channels.slack.allowBots=true ou channels.slack.channels.<id>.allowBots=true), evitez les boucles de reponse bot-a-bot avec des listes d’autorisation requireMention, channels.slack.channels.<id>.users, et/ou des garde-fous clairs dans AGENTS.md et SOUL.md.
  • Pour l’outil Slack, la semantique de suppression de reactions est decrite dans /tools/reactions.
  • Les pieces jointes sont telechargees vers le stockage media lorsque cela est autorise et en dessous de la limite de taille.