Passer au contenu principal

Slack

Statut : prêt pour la production pour les messages privés et les canaux via les intégrations d’app Slack. Le mode par défaut est Socket Mode ; les URL de requête HTTP sont également prises en charge.

Association

Les messages privés Slack utilisent par défaut le mode d’association.

Commandes slash

Comportement natif des commandes et catalogue des commandes.

Dépannage des canaux

Diagnostics inter-canaux et guides de réparation.

Configuration rapide

1

Créer une nouvelle app Slack

Dans les paramètres de l’app Slack, appuyez sur le bouton Create New App :
  • choisissez from a manifest et sélectionnez un espace de travail pour votre app
  • collez le manifeste d’exemple ci-dessous et continuez pour la créer
  • générez un App-Level Token (xapp-...) avec connections:write
  • installez l’app et copiez le Bot Token (xoxb-...) affiché
2

Configurer OpenClaw

{
  channels: {
    slack: {
      enabled: true,
      mode: "socket",
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}
Variable d’environnement de secours (compte par défaut uniquement) :
SLACK_APP_TOKEN=xapp-...
SLACK_BOT_TOKEN=xoxb-...
3

Démarrer la passerelle

openclaw gateway

Liste de vérification du manifeste et des portées

{
  "display_information": {
    "name": "OpenClaw",
    "description": "Slack connector for OpenClaw"
  },
  "features": {
    "bot_user": {
      "display_name": "OpenClaw",
      "always_online": true
    },
    "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": [
        "app_mentions:read",
        "assistant:write",
        "channels:history",
        "channels:read",
        "chat:write",
        "commands",
        "emoji:read",
        "files:read",
        "files:write",
        "groups:history",
        "groups:read",
        "im:history",
        "im:read",
        "im:write",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "pins:read",
        "pins:write",
        "reactions:read",
        "reactions:write",
        "users:read"
      ]
    }
  },
  "settings": {
    "socket_mode_enabled": true,
    "event_subscriptions": {
      "bot_events": [
        "app_mention",
        "channel_rename",
        "member_joined_channel",
        "member_left_channel",
        "message.channels",
        "message.groups",
        "message.im",
        "message.mpim",
        "pin_added",
        "pin_removed",
        "reaction_added",
        "reaction_removed"
      ]
    }
  }
}
Ajoutez la portée bot chat:write.customize si vous souhaitez que les messages sortants utilisent l’identité de l’agent actif (nom d’utilisateur et icône personnalisés) au lieu de l’identité par défaut de l’app Slack.Si vous utilisez une icône emoji, Slack attend une syntaxe :emoji_name:.
Si vous configurez channels.slack.userToken, les portées de lecture courantes 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 dépendez des lectures de recherche Slack)

Modèle de jeton

  • botToken + appToken sont requis pour Socket Mode.
  • Le mode HTTP nécessite botToken + signingSecret.
  • botToken, appToken, signingSecret et userToken acceptent des chaînes en clair ou des objets SecretRef.
  • Les jetons de config remplacent la variable d’environnement de secours.
  • La variable d’environnement de secours SLACK_BOT_TOKEN / SLACK_APP_TOKEN s’applique uniquement au compte par défaut.
  • userToken (xoxp-...) est uniquement configurable dans la config (pas de variable d’environnement de secours) et adopte par défaut un comportement en lecture seule (userTokenReadOnly: true).
Comportement de l’instantané d’état :
  • L’inspection du compte Slack suit, pour chaque identifiant, les champs *Source et *Status (botToken, appToken, signingSecret, userToken).
  • L’état est available, configured_unavailable ou missing.
  • configured_unavailable signifie que le compte est configuré via SecretRef ou une autre source de secret non inline, mais que le chemin de commande ou d’exécution actuel n’a pas pu résoudre la valeur réelle.
  • En mode HTTP, signingSecretStatus est inclus ; en Socket Mode, la paire requise est botTokenStatus + appTokenStatus.
Pour les actions et les lectures d’annuaire, le jeton utilisateur peut être préféré lorsqu’il est configuré. Pour les écritures, le jeton bot reste prioritaire ; les écritures avec jeton utilisateur ne sont autorisées que si userTokenReadOnly: false et que le jeton bot n’est pas disponible.

Actions et garde-fous

Les actions Slack sont contrôlées par channels.slack.actions.*. Groupes d’actions disponibles dans l’outillage Slack actuel :
GroupePar défaut
messagesactivé
reactionsactivé
pinsactivé
memberInfoactivé
emojiListactivé
Les actions de message Slack actuelles incluent send, upload-file, download-file, read, edit, delete, pin, unpin, list-pins, member-info et emoji-list.

Contrôle d’accès et routage

channels.slack.dmPolicy contrôle l’accès aux messages privés (hérité : channels.slack.dm.policy) :
  • pairing (par défaut)
  • allowlist
  • open (nécessite que channels.slack.allowFrom inclue "*" ; hérité : channels.slack.dm.allowFrom)
  • disabled
Indicateurs des messages privés :
  • dm.enabled (true par défaut)
  • channels.slack.allowFrom (préféré)
  • dm.allowFrom (hérité)
  • dm.groupEnabled (messages privés de groupe désactivés par défaut)
  • dm.groupChannels (liste d’autorisation MPIM facultative)
Priorité multi-compte :
  • channels.slack.accounts.default.allowFrom s’applique uniquement au compte default.
  • Les comptes nommés héritent de channels.slack.allowFrom lorsque leur propre allowFrom n’est pas défini.
  • Les comptes nommés n’héritent pas de channels.slack.accounts.default.allowFrom.
L’association dans les messages privés utilise openclaw pairing approve slack <code>.

Fils, sessions et balises de réponse

  • Les messages privés sont routés comme direct ; les canaux comme channel ; les MPIM comme group.
  • Avec la valeur par défaut session.dmScope=main, les messages privés Slack sont regroupés dans la session principale de l’agent.
  • Sessions de canal : agent:<agentId>:slack:channel:<channelId>.
  • Les réponses dans les fils peuvent créer des suffixes de session de fil (:thread:<threadTs>) lorsque c’est applicable.
  • La valeur par défaut de channels.slack.thread.historyScope est thread ; celle de thread.inheritParent est false.
  • channels.slack.thread.initialHistoryLimit contrôle le nombre de messages existants du fil récupérés au démarrage d’une nouvelle session de fil (valeur par défaut 20 ; définissez 0 pour désactiver).
  • channels.slack.thread.requireExplicitMention (par défaut false) : quand true, supprime les mentions implicites dans les fils afin que le bot ne réponde qu’aux mentions explicites @bot dans les fils, même s’il a déjà participé au fil. Sans cela, les réponses dans un fil auquel le bot a participé contournent le garde-fou requireMention.
Contrôles de fil de réponse :
  • channels.slack.replyToMode: off|first|all|batched (par défaut off)
  • channels.slack.replyToModeByChatType: par direct|group|channel
  • repli hérité pour les discussions directes : channels.slack.dm.replyToMode
Les balises de réponse manuelle sont prises en charge :
  • [[reply_to_current]]
  • [[reply_to:<id>]]
Remarque : replyToMode="off" désactive tout le fil de réponse dans Slack, y compris les balises explicites [[reply_to_*]]. Cela diffère de Telegram, où les balises explicites sont toujours respectées en mode "off". Cette différence reflète les modèles de fil propres aux plateformes : dans Slack, les fils masquent les messages du canal, tandis que dans Telegram, les réponses restent visibles dans le flux principal de discussion.

Réactions d’accusé de réception

ackReaction envoie un emoji d’accusé de réception pendant qu’OpenClaw traite un message entrant. Ordre de résolution :
  • channels.slack.accounts.<accountId>.ackReaction
  • channels.slack.ackReaction
  • messages.ackReaction
  • repli sur l’emoji d’identité de l’agent (agents.list[].identity.emoji, sinon ”👀”)
Remarques :
  • Slack attend des shortcodes (par exemple "eyes").
  • Utilisez "" pour désactiver la réaction pour le compte Slack ou globalement.

Streaming de texte

channels.slack.streaming contrôle le comportement de l’aperçu en direct :
  • off : désactiver le streaming de l’aperçu en direct.
  • partial (par défaut) : remplacer le texte d’aperçu par la dernière sortie partielle.
  • block : ajouter des mises à jour d’aperçu par blocs.
  • progress : afficher un texte de progression pendant la génération, puis envoyer le texte final.
channels.slack.streaming.nativeTransport contrôle le streaming de texte natif Slack lorsque channels.slack.streaming.mode vaut partial (par défaut : true).
  • Un fil de réponse doit être disponible pour que le streaming de texte natif et l’état du fil assistant Slack s’affichent. La sélection du fil continue toutefois de suivre replyToMode.
  • Les racines de canaux et de discussions de groupe peuvent toujours utiliser l’aperçu brouillon normal lorsque le streaming natif n’est pas disponible.
  • Les messages privés Slack de niveau supérieur restent hors fil par défaut, ils n’affichent donc pas l’aperçu de style fil ; utilisez des réponses en fil ou typingReaction si vous souhaitez y afficher une progression visible.
  • Les médias et les charges utiles non textuelles reviennent à la livraison normale.
  • Si le streaming échoue en cours de réponse, OpenClaw revient à la livraison normale pour les charges utiles restantes.
Utiliser l’aperçu brouillon au lieu du streaming de texte natif Slack :
{
  channels: {
    slack: {
      streaming: {
        mode: "partial",
        nativeTransport: false,
      },
    },
  },
}
Clés héritées :
  • channels.slack.streamMode (replace | status_final | append) est migré automatiquement vers channels.slack.streaming.mode.
  • le booléen channels.slack.streaming est migré automatiquement vers channels.slack.streaming.mode et channels.slack.streaming.nativeTransport.
  • la clé héritée channels.slack.nativeStreaming est migrée automatiquement vers channels.slack.streaming.nativeTransport.

Repli de réaction de saisie

typingReaction ajoute une réaction temporaire au message Slack entrant pendant qu’OpenClaw traite une réponse, puis la retire à la fin de l’exécution. C’est surtout utile hors des réponses en fil, qui utilisent un indicateur d’état par défaut « is typing… ». Ordre de résolution :
  • channels.slack.accounts.<accountId>.typingReaction
  • channels.slack.typingReaction
Remarques :
  • Slack attend des shortcodes (par exemple "hourglass_flowing_sand").
  • La réaction est appliquée au mieux et son nettoyage est tenté automatiquement une fois la réponse ou le chemin d’échec terminé.

Médias, découpage et livraison

Les pièces jointes Slack sont téléchargées depuis des URL privées hébergées par Slack (flux de requêtes authentifiées par jeton) et écrites dans le stockage média lorsque la récupération réussit et que les limites de taille le permettent.Le plafond de taille entrante à l’exécution est de 20MB par défaut, sauf remplacement par channels.slack.mediaMaxMb.
  • les blocs de texte utilisent channels.slack.textChunkLimit (valeur par défaut 4000)
  • channels.slack.chunkMode="newline" active un découpage privilégiant d’abord les paragraphes
  • les envois de fichiers utilisent les API d’upload Slack et peuvent inclure des réponses en fil (thread_ts)
  • le plafond média sortant suit channels.slack.mediaMaxMb lorsqu’il est configuré ; sinon, les envois par canal utilisent les valeurs par défaut par type MIME du pipeline média
Cibles explicites préférées :
  • user:<id> pour les messages privés
  • channel:<id> pour les canaux
Les messages privés Slack sont ouverts via les API de conversation Slack lors de l’envoi vers des cibles utilisateur.

Commandes et comportement des slash commands

  • Le mode automatique des commandes natives est désactivé pour Slack (commands.native: "auto" n’active pas les commandes natives Slack).
  • Activez les gestionnaires de commandes Slack natives avec channels.slack.commands.native: true (ou globalement commands.native: true).
  • Lorsque les commandes natives sont activées, enregistrez les slash commands correspondantes dans Slack (noms /<command>), avec une exception :
    • enregistrez /agentstatus pour la commande d’état (Slack réserve /status)
  • Si les commandes natives ne sont pas activées, vous pouvez exécuter une seule slash command configurée via channels.slack.slashCommand.
  • Les menus d’arguments natifs adaptent désormais leur stratégie de rendu :
    • jusqu’à 5 options : blocs de boutons
    • 6 à 100 options : menu de sélection statique
    • plus de 100 options : sélection externe avec filtrage asynchrone des options lorsque des gestionnaires d’options d’interactivité sont disponibles
    • si les valeurs d’option encodées dépassent les limites de Slack, le flux revient aux boutons
  • Pour les longues charges utiles d’options, les menus d’arguments des slash commands utilisent une boîte de dialogue de confirmation avant d’envoyer une valeur sélectionnée.
Paramètres par défaut des slash commands :
  • enabled: false
  • name: "openclaw"
  • sessionPrefix: "slack:slash"
  • ephemeral: true
Les sessions slash utilisent des clés isolées :
  • agent:<agentId>:slack:slash:<userId>
et continuent malgré tout à router l’exécution de la commande vers la session de conversation cible (CommandTargetSessionKey).

Réponses interactives

Slack peut afficher des contrôles de réponse interactive rédigés par l’agent, mais cette fonctionnalité est désactivée par défaut. L’activer globalement :
{
  channels: {
    slack: {
      capabilities: {
        interactiveReplies: true,
      },
    },
  },
}
Ou l’activer pour un seul compte Slack :
{
  channels: {
    slack: {
      accounts: {
        ops: {
          capabilities: {
            interactiveReplies: true,
          },
        },
      },
    },
  },
}
Lorsque cette fonctionnalité est activée, les agents peuvent émettre des directives de réponse réservées à Slack :
  • [[slack_buttons: Approve:approve, Reject:reject]]
  • [[slack_select: Choose a target | Canary:canary, Production:production]]
Ces directives sont compilées en Slack Block Kit et les clics ou sélections sont renvoyés via le chemin d’événement d’interaction Slack existant. Remarques :
  • Il s’agit d’une UI spécifique à Slack. Les autres canaux ne traduisent pas les directives Slack Block Kit vers leurs propres systèmes de boutons.
  • Les valeurs de rappel interactif sont des jetons opaques générés par OpenClaw, et non des valeurs brutes rédigées par l’agent.
  • Si les blocs interactifs générés dépassent les limites de Slack Block Kit, OpenClaw revient à la réponse texte d’origine au lieu d’envoyer une charge utile de blocs invalide.

Approbations exec dans Slack

Slack peut agir comme client d’approbation natif avec des boutons interactifs et des interactions, au lieu de revenir à la Web UI ou au terminal.
  • Les approbations exec utilisent channels.slack.execApprovals.* pour le routage natif en message privé/canal.
  • Les approbations de plugin peuvent toujours être résolues via la même surface de boutons native Slack lorsque la demande arrive déjà dans Slack et que le type d’ID d’approbation est plugin:.
  • L’autorisation des approbateurs reste appliquée : seuls les utilisateurs identifiés comme approbateurs peuvent approuver ou refuser des demandes via Slack.
Cela utilise la même surface partagée de boutons d’approbation que les autres canaux. Lorsque interactivity est activé dans les paramètres de votre app Slack, les invites d’approbation s’affichent directement sous forme de boutons Block Kit dans la conversation. Lorsque ces boutons sont présents, ils constituent l’UX d’approbation principale ; OpenClaw ne devrait inclure une commande manuelle /approve que lorsque le résultat de l’outil indique que les approbations par discussion ne sont pas disponibles ou que l’approbation manuelle est la seule voie. Chemin de configuration :
  • channels.slack.execApprovals.enabled
  • channels.slack.execApprovals.approvers (facultatif ; utilise commands.ownerAllowFrom comme repli lorsque possible)
  • channels.slack.execApprovals.target (dm | channel | both, valeur par défaut : dm)
  • agentFilter, sessionFilter
Slack active automatiquement les approbations exec natives lorsque enabled n’est pas défini ou vaut "auto" et qu’au moins un approbateur est résolu. Définissez enabled: false pour désactiver explicitement Slack comme client d’approbation natif. Définissez enabled: true pour forcer les approbations natives lorsque des approbateurs sont résolus. Comportement par défaut sans configuration explicite d’approbation exec Slack :
{
  commands: {
    ownerAllowFrom: ["slack:U12345678"],
  },
}
Une configuration native Slack explicite n’est nécessaire que si vous souhaitez remplacer les approbateurs, ajouter des filtres, ou opter pour une livraison vers la discussion d’origine :
{
  channels: {
    slack: {
      execApprovals: {
        enabled: true,
        approvers: ["U12345678"],
        target: "both",
      },
    },
  },
}
Le transfert partagé approvals.exec est distinct. Utilisez-le uniquement lorsque les invites d’approbation exec doivent aussi être routées vers d’autres discussions ou des cibles explicites hors bande. Le transfert partagé approvals.plugin est également distinct ; les boutons natifs Slack peuvent toujours résoudre les approbations de plugin lorsque ces demandes arrivent déjà dans Slack. /approve dans la même discussion fonctionne aussi dans les canaux et messages privés Slack qui prennent déjà en charge les commandes. Voir Approbations exec pour le modèle complet de transfert des approbations.

Événements et comportement opérationnel

  • Les modifications/suppressions de messages et les diffusions de fil sont mappées en événements système.
  • Les événements d’ajout/suppression de réaction sont mappés en événements système.
  • Les événements d’arrivée/départ de membre, de création/renommage de canal et d’ajout/suppression d’épingle sont mappés en événements système.
  • channel_id_changed peut migrer les clés de configuration de canal lorsque configWrites est activé.
  • Les métadonnées de sujet/objectifs de canal sont traitées comme un contexte non fiable et peuvent être injectées dans le contexte de routage.
  • Le message initial du fil et l’amorçage initial du contexte d’historique du fil sont filtrés selon les listes d’autorisation d’expéditeur configurées, lorsque applicable.
  • Les actions de bloc et les interactions modales émettent des événements système structurés Slack interaction: ... avec des champs riches de charge utile :
    • actions de bloc : valeurs sélectionnées, libellés, valeurs du sélecteur et métadonnées workflow_*
    • événements modaux view_submission et view_closed avec métadonnées de canal routées et entrées de formulaire

Pointeurs vers la référence de configuration

Référence principale :
  • Référence de configuration - Slack Champs Slack à fort signal :
    • mode/auth : mode, botToken, appToken, signingSecret, webhookPath, accounts.*
    • accès aux messages privés : dm.enabled, dmPolicy, allowFrom (hérité : dm.policy, dm.allowFrom), dm.groupEnabled, dm.groupChannels
    • option de compatibilité : dangerouslyAllowNameMatching (dernier recours ; laissez-la désactivée sauf nécessité)
    • accès aux canaux : groupPolicy, channels.*, channels.*.users, channels.*.requireMention
    • fils/historique : replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
    • livraison : textChunkLimit, chunkMode, mediaMaxMb, streaming, streaming.nativeTransport
    • opérations/fonctionnalités : configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

Dépannage

Vérifiez, dans l’ordre :
  • groupPolicy
  • liste d’autorisation des canaux (channels.slack.channels)
  • requireMention
  • liste d’autorisation users par canal
Commandes utiles :
openclaw channels status --probe
openclaw logs --follow
openclaw doctor
Vérifiez :
  • channels.slack.dm.enabled
  • channels.slack.dmPolicy (ou l’hérité channels.slack.dm.policy)
  • approbations d’association / entrées de liste d’autorisation
openclaw pairing list slack
Validez les jetons bot + app et l’activation de Socket Mode dans les paramètres de l’app Slack.Si openclaw channels status --probe --json affiche botTokenStatus ou appTokenStatus: "configured_unavailable", le compte Slack est configuré mais l’exécution actuelle n’a pas pu résoudre la valeur fournie via SecretRef.
Validez :
  • signing secret
  • chemin webhook
  • URL de requête Slack (Events + Interactivity + Slash Commands)
  • webhookPath unique par compte HTTP
Si signingSecretStatus: "configured_unavailable" apparaît dans les instantanés de compte, le compte HTTP est configuré mais l’exécution actuelle n’a pas pu résoudre le signing secret fourni via SecretRef.
Vérifiez ce que vous vouliez utiliser :
  • le mode de commande native (channels.slack.commands.native: true) avec les slash commands correspondantes enregistrées dans Slack
  • ou le mode de commande slash unique (channels.slack.slashCommand.enabled: true)
Vérifiez également commands.useAccessGroups et les listes d’autorisation de canaux/utilisateurs.

Liens connexes