Slack

Status: productieklaar voor DM’s + kanalen via Slack-app-integraties. Standaardmodus is Socket Mode; HTTP Events API-modus wordt ook ondersteund.

• Koppeling — Slack-DM’s staan standaard op koppelingsmodus.
• Slash-commando’s — Natief commandogedrag en commandocatalogus.
• Kanaalprobleemoplossing — Kanaaloverschrijdende diagnostiek en herstelhandboeken.

Snelle installatie

Socket Mode (standaard)

  ### Stap 1: Maak Slack-app en tokens aan
    In Slack-app-instellingen:

    - schakel **Socket Mode** in
    - maak **App Token** aan (`xapp-...`) met `connections:write`
    - installeer de app en kopieer **Bot Token** (`xoxb-...`)


  ### Stap 2: Configureer OpenClaw

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

    Env-terugval (alleen standaardaccount):

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

  ### Stap 3: Abonneer app-events
    Abonneer bot-events voor:

    - `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`

    Schakel ook App Home **Messages Tab** in voor DM's.


  ### Stap 4: Start de gateway

openclaw gateway

HTTP Events API-modus

  ### Stap 1: Configureer Slack-app voor HTTP

    - stel modus in op HTTP (`channels.slack.mode="http"`)
    - kopieer Slack **Signing Secret**
    - stel Event Subscriptions + Interactivity + Slash command Request URL in op hetzelfde webhookpad (standaard `/slack/events`)



  ### Stap 2: Configureer OpenClaw HTTP-modus

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

  ### Stap 3: Gebruik unieke webhookpaden voor multi-account HTTP
    Per-account HTTP-modus wordt ondersteund.

    Geef elk account een apart `webhookPath` zodat registraties niet botsen.

Tokenmodel

• botToken + appToken zijn vereist voor Socket Mode.
• HTTP-modus vereist botToken + signingSecret.
• Configtokens overschrijven env-terugval.
• SLACK_BOT_TOKEN / SLACK_APP_TOKEN env-terugval geldt alleen voor het standaardaccount.
• userToken (xoxp-...) is alleen config (geen env-terugval) en staat standaard op alleen-lezen-gedrag (userTokenReadOnly: true).
• Optioneel: voeg chat:write.customize toe als je wilt dat uitgaande berichten de actieve agent-identiteit gebruiken (aangepaste username en icoon). icon_emoji gebruikt :emoji_name:-syntaxis.

Tip: Voor acties/directory-reads kan het user token de voorkeur krijgen wanneer geconfigureerd. Voor schrijfacties heeft het bot token de voorkeur; user-token-schrijfacties zijn alleen toegestaan wanneer userTokenReadOnly: false en het bot token niet beschikbaar is.

Toegangscontrole en routering

DM-beleid

`channels.slack.dmPolicy` beheert DM-toegang (verouderd: `channels.slack.dm.policy`):

- `pairing` (standaard)
- `allowlist`
- `open` (vereist dat `channels.slack.allowFrom` `"*"` bevat; verouderd: `channels.slack.dm.allowFrom`)
- `disabled`

DM-vlaggen:

- `dm.enabled` (standaard true)
- `channels.slack.allowFrom` (voorkeur)
- `dm.allowFrom` (verouderd)
- `dm.groupEnabled` (groeps-DM's standaard false)
- `dm.groupChannels` (optionele MPIM-allowlist)

Multi-account-voorrang:

- `channels.slack.accounts.default.allowFrom` geldt alleen voor het `default`-account.
- Benoemde accounts erven `channels.slack.allowFrom` wanneer hun eigen `allowFrom` niet is ingesteld.
- Benoemde accounts erven niet `channels.slack.accounts.default.allowFrom`.

Koppeling in DM's gebruikt `openclaw pairing approve slack <code>`.

Kanaalbeleid

`channels.slack.groupPolicy` beheert kanaalafhandeling:

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

De kanaal-allowlist staat onder `channels.slack.channels` en moet stabiele kanaal-ID's gebruiken.

Runtime-opmerking: als `channels.slack` volledig ontbreekt (alleen env-setup), valt de runtime terug op `groupPolicy="allowlist"` en logt een waarschuwing (zelfs als `channels.defaults.groupPolicy` is ingesteld).

Naam/ID-resolutie:

- kanaal-allowlist-vermeldingen en DM-allowlist-vermeldingen worden bij opstart opgelost wanneer tokentoegang dit toestaat
- niet-opgeloste kanaalnaamvermeldingen worden bewaard zoals geconfigureerd maar standaard genegeerd voor routering
- inkomende autorisatie en kanaalroutering zijn standaard ID-eerst; directe gebruikersnaam-/slug-matching vereist `channels.slack.dangerouslyAllowNameMatching: true`

Vermeldingen en kanaalgebruikers

Kanaalberichten worden standaard vermelding-beveiligd.

Vermeldingsbronnen:

- expliciete app-vermelding (`<@botId>`)
- vermeldings-regexpatronen (`agents.list[].groupChat.mentionPatterns`, terugval `messages.groupChat.mentionPatterns`)
- impliciet antwoord-op-bot-threadgedrag

Per-kanaal-besturingselementen (`channels.slack.channels.<id>`; namen alleen via opstarresolutie of `dangerouslyAllowNameMatching`):

- `requireMention`
- `users` (allowlist)
- `allowBots`
- `skills`
- `systemPrompt`
- `tools`, `toolsBySender`
- `toolsBySender`-sleutelformaat: `id:`, `e164:`, `username:`, `name:`, of `"*"` wildcard
  (verouderde niet-geprefixte sleutels mappen nog steeds naar alleen `id:`)

Commando’s en slash-gedrag

• Native-commando-automodus is uit voor Slack (commands.native: "auto" schakelt Slack-native-commando’s niet in).
• Schakel native Slack-commandohandlers in met channels.slack.commands.native: true (of globaal commands.native: true).
• Wanneer native commando’s zijn ingeschakeld, registreer overeenkomende slash-commando’s in Slack (/<commando>-namen), met een uitzondering:
  • registreer /agentstatus voor het statuscommando (Slack reserveert /status)
• Als native commando’s niet zijn ingeschakeld, kun je een enkel geconfigureerd slash-commando draaien via channels.slack.slashCommand.
• Native arg-menu’s passen nu hun renderingstrategie aan:
  • tot 5 opties: knopblokken
  • 6-100 opties: statisch selectiemenu
  • meer dan 100 opties: extern selectiemenu met asynchrone optiefiltering wanneer interactiviteitsoptiehandlers beschikbaar zijn
  • als gecodeerde optiewaarden Slack-limieten overschrijden, valt de flow terug op knoppen
• Voor lange optiepayloads gebruiken slash-commando-argumentmenu’s een bevestigingsdialoog voordat een geselecteerde waarde wordt verzonden.

Interactieve antwoorden

Slack kan door agents geschreven interactieve antwoordbesturingselementen renderen, maar deze functie is standaard uitgeschakeld.

Globaal inschakelen:

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

Of schakel het in voor slechts een Slack-account:

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

Wanneer ingeschakeld, kunnen agents Slack-specifieke antwoorddirectieven uitzenden:

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

Deze directieven worden gecompileerd naar Slack Block Kit en routeren klikken of selecties terug via het bestaande Slack-interactie-eventpad.

Opmerkingen:

• Dit is Slack-specifieke UI. Andere kanalen vertalen Slack Block Kit-directieven niet naar hun eigen knopsystemen.
• De interactieve callbackwaarden zijn door OpenClaw gegenereerde ondoorzichtige tokens, geen onbewerkte door agents geschreven waarden.
• Als gegenereerde interactieve blokken Slack Block Kit-limieten zouden overschrijden, valt OpenClaw terug op het oorspronkelijke tekstantwoord in plaats van een ongeldige blokpayload te versturen.

Standaard slash-commando-instellingen:

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

Slash-sessies gebruiken geïsoleerde sleutels:

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

en routeren commandouitvoering nog steeds tegen de doelgesprekssessie (CommandTargetSessionKey).

Threading, sessies en reply-tags

• DM’s routeren als direct; kanalen als channel; MPIM’s als group.
• Met standaard session.dmScope=main worden Slack-DM’s samengevoegd in de agent-hoofdsessie.
• Kanaalsessies: agent:<agentId>:slack:channel:<channelId>.
• Thread-antwoorden kunnen thread-sessiesuffixen aanmaken (:thread:<threadTs>) wanneer van toepassing.
• channels.slack.thread.historyScope standaard is thread; thread.inheritParent standaard is false.
• channels.slack.thread.initialHistoryLimit bepaalt hoeveel bestaande threadberichten worden opgehaald wanneer een nieuwe threadsessie start (standaard 20; stel 0 in om uit te schakelen).

Reply-threading-besturingselementen:

• channels.slack.replyToMode: off|first|all (standaard off)
• channels.slack.replyToModeByChatType: per direct|group|channel
• verouderde terugval voor directe chats: channels.slack.dm.replyToMode

Handmatige reply-tags worden ondersteund:

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

Opmerking: replyToMode="off" schakelt alle reply-threading in Slack uit, inclusief expliciete [[reply_to_*]]-tags. Dit verschilt van Telegram, waar expliciete tags nog steeds worden gehonoreerd in "off"-modus. Het verschil weerspiegelt de platformthreadingmodellen: Slack-threads verbergen berichten uit het kanaal, terwijl Telegram-antwoorden zichtbaar blijven in de hoofdchatflow.

Media, opsplitsing en aflevering

Slack-bestandsbijlagen worden gedownload van door Slack gehoste privé-URL's (token-geauthenticeerde request-flow) en naar de mediaopslag geschreven wanneer het ophalen slaagt en grootte-limieten het toelaten.

Runtime inkomende groottelimiet is standaard `20MB` tenzij overschreven door `channels.slack.mediaMaxMb`.

- tekstchunks gebruiken `channels.slack.textChunkLimit` (standaard 4000)
- `channels.slack.chunkMode="newline"` schakelt alinea-eerst-opsplitsing in
- bestandverzendingen gebruiken Slack upload-API's en kunnen thread-antwoorden bevatten (`thread_ts`)
- uitgaande medialimiet volgt `channels.slack.mediaMaxMb` wanneer geconfigureerd; anders gebruiken kanaalverzendingen MIME-standaarden uit de mediapipeline

Voorkeur expliciete doelen:

- `user:<id>` voor DM's
- `channel:<id>` voor kanalen

Slack-DM's worden geopend via Slack-conversatie-API's bij het versturen naar gebruikersdoelen.

Acties en gates

Slack-acties worden beheerd door channels.slack.actions.*.

Beschikbare actiegroepen in de huidige Slack-tooling:

Events en operationeel gedrag

• Berichtbewerkingen/-verwijderingen/thread-broadcasts worden omgezet naar systeemevents.
• Reactietoevoeg-/verwijderevents worden omgezet naar systeemevents.
• Lid-toetreedt/verlaat-, kanaal-aangemaakt/hernoemd- en pin-toevoeg/verwijderevents worden omgezet naar systeemevents.
• Assistent-threadstatusupdate (voor “is aan het typen…”-indicatoren in threads) gebruiken assistant.threads.setStatus en vereisen bot-scope assistant:write.
• channel_id_changed kan kanaalconfiguratiesleutels migreren wanneer configWrites is ingeschakeld.
• Kanaalonderwerp-/doelmetadata wordt behandeld als niet-vertrouwde context en kan worden geïnjecteerd in de routeringscontext.
• Blokacties en modale interacties zenden gestructureerde Slack interaction: ... systeemevents uit met rijke payloadvelden:
  • blokacties: geselecteerde waarden, labels, pickerwaarden en workflow_*-metadata
  • modale view_submission- en view_closed-events met gerouteerde kanaalmetadata en formulierinvoer

Bevestigingsreacties

ackReaction stuurt een bevestigingsemoji terwijl OpenClaw een inkomend bericht verwerkt.

Resolutievolgorde:

• channels.slack.accounts.<accountId>.ackReaction
• channels.slack.ackReaction
• messages.ackReaction
• agent-identiteitsemoji-terugval (agents.list[].identity.emoji, anders ”👀”)

Opmerkingen:

• Slack verwacht shortcodes (bijvoorbeeld "eyes").
• Gebruik "" om de reactie voor het Slack-account of globaal uit te schakelen.

Typreactie-terugval

typingReaction voegt een tijdelijke reactie toe aan het inkomende Slack-bericht terwijl OpenClaw een antwoord verwerkt, en verwijdert deze wanneer de verwerking is voltooid. Dit is een nuttige terugval wanneer Slack-native assistent-typen niet beschikbaar is, vooral bij DM’s.

Resolutievolgorde:

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

Opmerkingen:

• Slack verwacht shortcodes (bijvoorbeeld "hourglass_flowing_sand").
• De reactie is best-effort en opruiming wordt automatisch geprobeerd nadat het antwoord of het foutpad is voltooid.

Manifest en scope-checklist

{
  "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"
      ]
    }
  }
}

Als je `channels.slack.userToken` configureert, zijn typische leesscopes:

- `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` (als je afhankelijk bent van Slack-zoek-reads)

Probleemoplossing

Controleer, in volgorde:

- `groupPolicy`
- kanaal-allowlist (`channels.slack.channels`)
- `requireMention`
- per-kanaal `users`-allowlist

Nuttige commando's:

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

Controleer:

- `channels.slack.dm.enabled`
- `channels.slack.dmPolicy` (of verouderd `channels.slack.dm.policy`)
- koppelingsgoedkeuringen / allowlist-vermeldingen

openclaw pairing list slack

Valideer bot- + app-tokens en Socket Mode-inschakeling in Slack-app-instellingen.

Valideer:

- signing secret
- webhookpad
- Slack Request-URL's (Events + Interactivity + Slash Commands)
- uniek `webhookPath` per HTTP-account

Verifieer of je bedoelde:

- native commandomodus (`channels.slack.commands.native: true`) met overeenkomende slash-commando's geregistreerd in Slack
- of enkele slash-commandomodus (`channels.slack.slashCommand.enabled: true`)

Controleer ook `commands.useAccessGroups` en kanaal-/gebruiker-allowlists.

Tekststreaming

OpenClaw ondersteunt Slack-native tekststreaming via de Agents and AI Apps API.

channels.slack.streaming beheert live preview-gedrag:

• off: live preview-streaming uitschakelen.
• partial (standaard): preview-tekst vervangen door de laatste deeluitvoer.
• block: gegroepeerde preview-updates toevoegen.
• progress: voortgangsstatustekst tonen tijdens genereren, daarna uiteindelijke tekst versturen.

channels.slack.nativeStreaming beheert Slack’s native streaming-API (chat.startStream / chat.appendStream / chat.stopStream) wanneer streaming partial is (standaard: true).

Slack-native streaming uitschakelen (preview-gedrag behouden):

channels:
  slack:
    streaming: partial
    nativeStreaming: false

Verouderde sleutels:

• channels.slack.streamMode (replace | status_final | append) wordt automatisch gemigreerd naar channels.slack.streaming.
• boolean channels.slack.streaming wordt automatisch gemigreerd naar channels.slack.nativeStreaming.

Vereisten

1. Schakel Agents and AI Apps in je Slack-app-instellingen in.
2. Zorg ervoor dat de app de assistant:write-scope heeft.
3. Er moet een antwoord-thread beschikbaar zijn voor dat bericht. Threadselectie volgt nog steeds replyToMode.

Gedrag

• Eerste tekstchunk start een stream (chat.startStream).
• Latere tekstchunks worden aan dezelfde stream toegevoegd (chat.appendStream).
• Einde van antwoord finaliseert de stream (chat.stopStream).
• Media en niet-tekstpayloads vallen terug op normale aflevering.
• Als streaming halverwege een antwoord faalt, valt OpenClaw terug op normale aflevering voor resterende payloads.

Configuratiereferentie-verwijzingen

Primaire referentie:

• Configuratiereferentie - Slack

  Belangrijkste Slack-velden:

  • modus/auth: mode, botToken, appToken, signingSecret, webhookPath, accounts.*
  • DM-toegang: dm.enabled, dmPolicy, allowFrom (verouderd: dm.policy, dm.allowFrom), dm.groupEnabled, dm.groupChannels
  • compatibiliteitschakelaar: dangerouslyAllowNameMatching (noodoplossing; houd uit tenzij nodig)
  • kanaaltoegang: groupPolicy, channels.*, channels.*.users, channels.*.requireMention
  • threading/geschiedenis: replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
  • aflevering: textChunkLimit, chunkMode, mediaMaxMb, streaming, nativeStreaming
  • ops/functies: configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

Gerelateerd

• Koppeling
• Kanaalroutering
• Probleemoplossing
• Configuratie
• Slash-commando’s