> ## Documentation Index
> Fetch the complete documentation index at: https://docs2.openclaw.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Slack
Productieklaar voor DM's en kanalen via Slack-appintegraties. De standaardmodus is Socket Mode; HTTP Request-URL's worden ook ondersteund. Relay-modus is bedoeld voor beheerde deployments waarbij een vertrouwde router Slack-ingress beheert.
Slack-DM's gebruiken standaard de koppelingsmodus.
Native opdrachtgedrag en opdrachtcatalogus.
Cross-channel diagnostiek en reparatieplaybooks.
## Socket Mode of HTTP Request-URL's kiezen
Beide transports zijn productieklaar en bereiken feature parity voor messaging, slash commands, App Home en interactiviteit. Kies op basis van deploymentvorm, niet op basis van features.
| Aandachtspunt | Socket Mode (standaard) | HTTP Request-URL's |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| Publieke Gateway-URL | Niet vereist | Vereist (DNS, TLS, reverse proxy of tunnel) |
| Uitgaand netwerk | Uitgaande WSS naar `wss-primary.slack.com` moet bereikbaar zijn | Geen uitgaande WS; alleen inkomende HTTPS |
| Benodigde tokens | Bottoken + App-Level Token met `connections:write` | Bottoken + Signing Secret |
| Dev-laptop / achter firewall | Werkt zonder verdere aanpassingen | Heeft een publieke tunnel (ngrok, Cloudflare Tunnel, Tailscale Funnel) of staging-Gateway nodig |
| Horizontaal schalen | Eén Socket Mode-sessie per app per host; meerdere Gateways hebben afzonderlijke Slack-apps nodig | Stateless POST-handler; meerdere Gateway-replica's kunnen één app achter een load balancer delen |
| Meerdere accounts op één Gateway | Ondersteund; elk account opent zijn eigen WS | Ondersteund; elk account heeft een unieke `webhookPath` nodig (standaard `/slack/events`) zodat registraties niet botsen |
| Slash command-transport | Geleverd via de WS-verbinding; `slash_commands[].url` wordt genegeerd | Slack POST naar `slash_commands[].url`; veld is vereist om de opdracht te dispatchen |
| Request signing | Niet gebruikt (auth is de App-Level Token) | Slack ondertekent elk verzoek; OpenClaw verifieert met `signingSecret` |
| Herstel bij verbindingsuitval | Automatisch opnieuw verbinden van de Slack-SDK is ingeschakeld; OpenClaw herstart mislukte Socket Mode-sessies ook met begrensde backoff. Transporttuning voor pong-time-outs is van toepassing. | Geen persistente verbinding die kan wegvallen; retries gebeuren per verzoek vanuit Slack |
**Kies Socket Mode** voor hosts met één Gateway, dev-laptops en on-prem-netwerken die `*.slack.com` uitgaand kunnen bereiken maar geen inkomende HTTPS kunnen accepteren.
**Kies HTTP Request-URL's** wanneer je meerdere Gateway-replica's achter een load balancer uitvoert, wanneer uitgaande WSS geblokkeerd is maar inkomende HTTPS is toegestaan, of wanneer je Slack-webhooks al op een reverse proxy termineert.
### Relay-modus
Relay-modus scheidt Slack-ingress van de OpenClaw-gateway. Een vertrouwde router beheert de
enkele Slack Socket Mode-verbinding, kiest een doelgateway en stuurt een getypeerde
event door via een geauthenticeerde websocket. De gateway blijft zijn bottoken gebruiken voor
uitgaande Slack Web API-aanroepen.
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
mode: "relay",
botToken: { source: "env", provider: "default", id: "SLACK_BOT_TOKEN" },
relay: {
url: "wss://router.example.com/gateway/ws",
authToken: { source: "env", provider: "default", id: "SLACK_RELAY_AUTH_TOKEN" },
gatewayId: "team-gateway",
},
},
},
}
```
De relay-URL moet `wss://` gebruiken, tenzij deze naar localhost verwijst. Behandel het bearer-token en
de routeertabel van de router als onderdeel van de Slack-autorisatiegrens: gerouteerde events komen de
normale Slack-berichthandler binnen als geautoriseerde activaties. Een door de router geleverde `slack_identity`
in het websocket-`hello`-frame kan de standaard uitgaande gebruikersnaam en het pictogram instellen; een expliciete
identiteit die door de caller wordt geleverd, wint nog steeds. De relay-verbinding maakt opnieuw verbinding met dezelfde
begrensde backoff-timing die door Socket Mode wordt gebruikt en wist de door de router geleverde identiteit telkens wanneer
de verbinding wordt verbroken.
## Installeren
Installeer Slack voordat je het kanaal configureert:
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
openclaw plugins install @openclaw/slack
```
`plugins install` registreert en activeert de Plugin. De Plugin doet nog steeds niets totdat je de Slack-app en kanaalinstellingen hieronder configureert. Zie [Plugins](/nl/tools/plugin) voor algemeen Plugin-gedrag en installatieregels.
## Snelle configuratie
Open [api.slack.com/apps](https://api.slack.com/apps/new) → **Create New App** → **From a manifest** → selecteer je workspace → plak een van de onderstaande manifests → **Next** → **Create**.
```json Recommended theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"display_information": {
"name": "OpenClaw",
"description": "Slack connector for OpenClaw"
},
"features": {
"bot_user": { "display_name": "OpenClaw", "always_online": true },
"app_home": {
"home_tab_enabled": true,
"messages_tab_enabled": true,
"messages_tab_read_only_enabled": false
},
"assistant_view": {
"assistant_description": "OpenClaw connects Slack assistant threads to OpenClaw agents.",
"suggested_prompts": [
{ "title": "What can you do?", "message": "What can you help me with?" },
{
"title": "Summarize this channel",
"message": "Summarize the recent activity in this channel."
},
{ "title": "Draft a reply", "message": "Help me draft a reply." }
]
},
"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",
"usergroups:read",
"users:read"
]
}
},
"settings": {
"socket_mode_enabled": true,
"event_subscriptions": {
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"channel_rename",
"member_joined_channel",
"member_left_channel",
"message.channels",
"message.groups",
"message.im",
"message.mpim",
"pin_added",
"pin_removed",
"reaction_added",
"reaction_removed"
]
}
}
}
```
```json Minimal theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"display_information": {
"name": "OpenClaw",
"description": "Slack connector for OpenClaw"
},
"features": {
"bot_user": { "display_name": "OpenClaw", "always_online": true },
"app_home": {
"home_tab_enabled": true,
"messages_tab_enabled": true,
"messages_tab_read_only_enabled": false
},
"assistant_view": {
"assistant_description": "OpenClaw connects Slack assistant threads to OpenClaw agents.",
"suggested_prompts": [
{ "title": "What can you do?", "message": "What can you help me with?" },
{
"title": "Summarize this channel",
"message": "Summarize the recent activity in this channel."
},
{ "title": "Draft a reply", "message": "Help me draft a reply." }
]
},
"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",
"groups:history",
"groups:read",
"im:history",
"im:read",
"im:write",
"users:read"
]
}
},
"settings": {
"socket_mode_enabled": true,
"event_subscriptions": {
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"message.channels",
"message.groups",
"message.im"
]
}
}
}
```
**Recommended** komt overeen met de volledige featureset van de Slack-Plugin: App Home, slash commands, bestanden, reacties, pins, groeps-DM's en emoji-/gebruikersgroepleestoegang. Kies **Minimal** wanneer workspacebeleid scopes beperkt — dit dekt DM's, kanaal-/groepsgeschiedenis, vermeldingen en slash commands, maar laat bestanden, reacties, pins, groeps-DM (`mpim:*`), `emoji:read` en `usergroups:read` weg. Zie [Checklist voor manifest en scopes](#manifest-and-scope-checklist) voor de rationale per scope en additieve opties zoals extra slash commands.
Nadat Slack de app heeft gemaakt:
* **Basic Information -> App-Level Tokens -> Generate Token and Scopes**: voeg `connections:write` toe, sla op en kopieer de App-Level Token.
* **Install App -> Install to Workspace**: kopieer de Bot User OAuth Token.
Aanbevolen SecretRef-configuratie:
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
export SLACK_APP_TOKEN=slack-app-token-example
export SLACK_BOT_TOKEN=slack-bot-token-example
cat > slack.socket.patch.json5 <<'JSON5'
{
channels: {
slack: {
enabled: true,
mode: "socket",
appToken: { source: "env", provider: "default", id: "SLACK_APP_TOKEN" },
botToken: { source: "env", provider: "default", id: "SLACK_BOT_TOKEN" },
},
},
}
JSON5
openclaw config patch --file ./slack.socket.patch.json5 --dry-run
openclaw config patch --file ./slack.socket.patch.json5
```
Env-fallback (alleen standaardaccount):
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
SLACK_APP_TOKEN=slack-app-token-example
SLACK_BOT_TOKEN=slack-bot-token-example
```
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
openclaw gateway
```
Open [api.slack.com/apps](https://api.slack.com/apps/new) → **Nieuwe app maken** → **Vanuit een manifest** → selecteer je workspace → plak een van de onderstaande manifests → vervang `https://gateway-host.example.com/slack/events` door je openbare Gateway-URL → **Volgende** → **Maken**.
```json Recommended theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"display_information": {
"name": "OpenClaw",
"description": "Slack connector for OpenClaw"
},
"features": {
"bot_user": { "display_name": "OpenClaw", "always_online": true },
"app_home": {
"home_tab_enabled": true,
"messages_tab_enabled": true,
"messages_tab_read_only_enabled": false
},
"assistant_view": {
"assistant_description": "OpenClaw connects Slack assistant threads to OpenClaw agents.",
"suggested_prompts": [
{ "title": "What can you do?", "message": "What can you help me with?" },
{
"title": "Summarize this channel",
"message": "Summarize the recent activity in this channel."
},
{ "title": "Draft a reply", "message": "Help me draft a reply." }
]
},
"slash_commands": [
{
"command": "/openclaw",
"description": "Send a message to OpenClaw",
"should_escape": false,
"url": "https://gateway-host.example.com/slack/events"
}
]
},
"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",
"usergroups:read",
"users:read"
]
}
},
"settings": {
"event_subscriptions": {
"request_url": "https://gateway-host.example.com/slack/events",
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"channel_rename",
"member_joined_channel",
"member_left_channel",
"message.channels",
"message.groups",
"message.im",
"message.mpim",
"pin_added",
"pin_removed",
"reaction_added",
"reaction_removed"
]
},
"interactivity": {
"is_enabled": true,
"request_url": "https://gateway-host.example.com/slack/events",
"message_menu_options_url": "https://gateway-host.example.com/slack/events"
}
}
}
```
```json Minimal theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"display_information": {
"name": "OpenClaw",
"description": "Slack connector for OpenClaw"
},
"features": {
"bot_user": { "display_name": "OpenClaw", "always_online": true },
"app_home": {
"home_tab_enabled": true,
"messages_tab_enabled": true,
"messages_tab_read_only_enabled": false
},
"assistant_view": {
"assistant_description": "OpenClaw connects Slack assistant threads to OpenClaw agents.",
"suggested_prompts": [
{ "title": "What can you do?", "message": "What can you help me with?" },
{
"title": "Summarize this channel",
"message": "Summarize the recent activity in this channel."
},
{ "title": "Draft a reply", "message": "Help me draft a reply." }
]
},
"slash_commands": [
{
"command": "/openclaw",
"description": "Send a message to OpenClaw",
"should_escape": false,
"url": "https://gateway-host.example.com/slack/events"
}
]
},
"oauth_config": {
"scopes": {
"bot": [
"app_mentions:read",
"assistant:write",
"channels:history",
"channels:read",
"chat:write",
"commands",
"groups:history",
"groups:read",
"im:history",
"im:read",
"im:write",
"users:read"
]
}
},
"settings": {
"event_subscriptions": {
"request_url": "https://gateway-host.example.com/slack/events",
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"message.channels",
"message.groups",
"message.im"
]
},
"interactivity": {
"is_enabled": true,
"request_url": "https://gateway-host.example.com/slack/events",
"message_menu_options_url": "https://gateway-host.example.com/slack/events"
}
}
}
```
**Aanbevolen** komt overeen met de volledige functieset van de Slack-Plugin; **Minimaal** laat bestanden, reacties, pins, groeps-DM (`mpim:*`), `emoji:read` en `usergroups:read` weg voor restrictieve workspaces. Zie [Manifest- en scope-checklist](#manifest-and-scope-checklist) voor de reden per scope.
De drie URL-velden (`slash_commands[].url`, `event_subscriptions.request_url` en `interactivity.request_url` / `message_menu_options_url`) verwijzen allemaal naar hetzelfde OpenClaw-eindpunt. Het manifestschema van Slack vereist dat ze afzonderlijk worden benoemd, maar OpenClaw routeert op payloadtype, dus één `webhookPath` (standaard `/slack/events`) is voldoende. Slash commands zonder `slash_commands[].url` doen in HTTP-modus stilzwijgend niets.
Nadat Slack de app heeft gemaakt:
* **Basisinformatie → Appreferenties**: kopieer het **Signing Secret** voor aanvraagverificatie.
* **App installeren -> Installeren in workspace**: kopieer het Bot User OAuth Token.
Aanbevolen SecretRef-configuratie:
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
export SLACK_BOT_TOKEN=slack-bot-token-example
export SLACK_SIGNING_SECRET=...
cat > slack.http.patch.json5 <<'JSON5'
{
channels: {
slack: {
enabled: true,
mode: "http",
botToken: { source: "env", provider: "default", id: "SLACK_BOT_TOKEN" },
signingSecret: { source: "env", provider: "default", id: "SLACK_SIGNING_SECRET" },
webhookPath: "/slack/events",
},
},
}
JSON5
openclaw config patch --file ./slack.http.patch.json5 --dry-run
openclaw config patch --file ./slack.http.patch.json5
```
Gebruik unieke Webhook-paden voor HTTP met meerdere accounts
Geef elk account een eigen `webhookPath` (standaard `/slack/events`), zodat registraties niet botsen.
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
openclaw gateway
```
## Socket Mode-transportafstemming
OpenClaw stelt de pong-time-out van de Slack SDK-client standaard in op 15 seconden voor Socket Mode. Overschrijf de transportinstellingen alleen wanneer je workspace- of hostspecifieke afstemming nodig hebt:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
mode: "socket",
socketMode: {
clientPingTimeout: 20000,
serverPingTimeout: 30000,
pingPongLoggingEnabled: false,
},
},
},
}
```
Gebruik dit alleen voor Socket Mode-workspaces die Slack websocket pong/server-ping-time-outs loggen of draaien op hosts met bekende event-loop starvation. `clientPingTimeout` is de wachttijd op pong nadat de SDK een client-ping heeft verzonden; `serverPingTimeout` is de wachttijd op Slack-serverpings. Appberichten en events blijven applicatiestatus, geen signalen voor transport-liveness.
Opmerkingen:
* `socketMode` wordt genegeerd in HTTP Request URL-modus.
* Basisinstellingen voor `channels.slack.socketMode` gelden voor alle Slack-accounts tenzij ze worden overschreven. Overrides per account gebruiken `channels.slack.accounts..socketMode`; omdat dit een object-override is, moet je elk socketafstemmingsveld opnemen dat je voor dat account wilt.
* Alleen `clientPingTimeout` heeft een OpenClaw-standaardwaarde (`15000`). `serverPingTimeout` en `pingPongLoggingEnabled` worden alleen aan de Slack SDK doorgegeven wanneer ze zijn geconfigureerd.
* Restart-backoff voor Socket Mode begint rond 2 seconden en wordt begrensd rond 30 seconden. Herstelbare start-, start-wait- en disconnect-fouten proberen opnieuw totdat het kanaal stopt. Permanente account- en referentiefouten zoals ongeldige auth, ingetrokken tokens of ontbrekende scopes falen snel in plaats van eindeloos opnieuw te proberen.
## Manifest- en scope-checklist
Het basismanifest voor de Slack-app is hetzelfde voor Socket Mode en HTTP Request URLs. Alleen het blok `settings` (en de slash command-`url`) verschilt.
Basemanifest (standaard voor Socket Mode):
```json theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"display_information": {
"name": "OpenClaw",
"description": "Slack connector for OpenClaw"
},
"features": {
"bot_user": { "display_name": "OpenClaw", "always_online": true },
"app_home": {
"home_tab_enabled": true,
"messages_tab_enabled": true,
"messages_tab_read_only_enabled": false
},
"assistant_view": {
"assistant_description": "OpenClaw connects Slack assistant threads to OpenClaw agents.",
"suggested_prompts": [
{ "title": "What can you do?", "message": "What can you help me with?" },
{
"title": "Summarize this channel",
"message": "Summarize the recent activity in this channel."
},
{ "title": "Draft a reply", "message": "Help me draft a reply." }
]
},
"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",
"usergroups:read",
"users:read"
]
}
},
"settings": {
"socket_mode_enabled": true,
"event_subscriptions": {
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"channel_rename",
"member_joined_channel",
"member_left_channel",
"message.channels",
"message.groups",
"message.im",
"message.mpim",
"pin_added",
"pin_removed",
"reaction_added",
"reaction_removed"
]
}
}
}
```
Voor **HTTP Request URLs-modus** vervang je `settings` door de HTTP-variant en voeg je `url` toe aan elke slash command. Openbare URL vereist:
```json theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"features": {
"slash_commands": [
{
"command": "/openclaw",
"description": "Send a message to OpenClaw",
"should_escape": false,
"url": "https://gateway-host.example.com/slack/events"
}
]
},
"settings": {
"event_subscriptions": {
"request_url": "https://gateway-host.example.com/slack/events",
"bot_events": [
"app_home_opened",
"app_mention",
"assistant_thread_context_changed",
"assistant_thread_started",
"channel_rename",
"member_joined_channel",
"member_left_channel",
"message.channels",
"message.groups",
"message.im",
"message.mpim",
"pin_added",
"pin_removed",
"reaction_added",
"reaction_removed"
]
},
"interactivity": {
"is_enabled": true,
"request_url": "https://gateway-host.example.com/slack/events",
"message_menu_options_url": "https://gateway-host.example.com/slack/events"
}
}
}
```
### Aanvullende manifestinstellingen
Toon verschillende functies die de bovenstaande standaarden uitbreiden.
Het standaardmanifest schakelt het Slack App Home-tabblad **Home** in en abonneert zich op `app_home_opened`. Wanneer een werkruimtelid het tabblad Home opent, publiceert OpenClaw een veilige standaardweergave voor Home met `views.publish`; er wordt geen gesprekspayload of privéconfiguratie opgenomen. Het tabblad **Messages** blijft ingeschakeld voor Slack-DM's. Het manifest schakelt ook Slack-assistentthreads in met `features.assistant_view`, `assistant:write`, `assistant_thread_started` en `assistant_thread_context_changed`; assistentthreads worden naar hun eigen OpenClaw-threadsessies gerouteerd en houden door Slack geleverde threadcontext beschikbaar voor de agent.
Meerdere [native slash commands](#commands-and-slash-behavior) kunnen met nuance worden gebruikt in plaats van één geconfigureerde opdracht:
* Gebruik `/agentstatus` in plaats van `/status`, omdat de opdracht `/status` is gereserveerd.
* Er kunnen niet meer dan 25 slash commands tegelijk beschikbaar worden gemaakt.
Vervang je bestaande sectie `features.slash_commands` door een subset van [beschikbare opdrachten](/nl/tools/slash-commands#command-list):
```json theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"slash_commands": [
{
"command": "/new",
"description": "Start a new session",
"usage_hint": "[model]"
},
{
"command": "/reset",
"description": "Reset the current session"
},
{
"command": "/compact",
"description": "Compact the session context",
"usage_hint": "[instructions]"
},
{
"command": "/stop",
"description": "Stop the current run"
},
{
"command": "/session",
"description": "Manage thread-binding expiry",
"usage_hint": "idle or max-age "
},
{
"command": "/think",
"description": "Set the thinking level",
"usage_hint": ""
},
{
"command": "/verbose",
"description": "Toggle verbose output",
"usage_hint": "on|off|full"
},
{
"command": "/fast",
"description": "Show or set fast mode",
"usage_hint": "[status|on|off]"
},
{
"command": "/reasoning",
"description": "Toggle reasoning visibility",
"usage_hint": "[on|off|stream]"
},
{
"command": "/elevated",
"description": "Toggle elevated mode",
"usage_hint": "[on|off|ask|full]"
},
{
"command": "/exec",
"description": "Show or set exec defaults",
"usage_hint": "host= security= ask= node="
},
{
"command": "/approve",
"description": "Approve or deny pending approval requests",
"usage_hint": " "
},
{
"command": "/model",
"description": "Show or set the model",
"usage_hint": "[name|#|status]"
},
{
"command": "/models",
"description": "List providers/models",
"usage_hint": "[provider] [page] [limit=|size=|all]"
},
{
"command": "/help",
"description": "Show the short help summary"
},
{
"command": "/commands",
"description": "Show the generated command catalog"
},
{
"command": "/tools",
"description": "Show what the current agent can use right now",
"usage_hint": "[compact|verbose]"
},
{
"command": "/agentstatus",
"description": "Show runtime status, including provider usage/quota when available"
},
{
"command": "/tasks",
"description": "List active/recent background tasks for the current session"
},
{
"command": "/context",
"description": "Explain how context is assembled",
"usage_hint": "[list|detail|json]"
},
{
"command": "/whoami",
"description": "Show your sender identity"
},
{
"command": "/skill",
"description": "Run a skill by name",
"usage_hint": " [input]"
},
{
"command": "/btw",
"description": "Ask a side question without changing session context",
"usage_hint": ""
},
{
"command": "/side",
"description": "Ask a side question without changing session context",
"usage_hint": ""
},
{
"command": "/usage",
"description": "Control the usage footer or show cost summary",
"usage_hint": "off|tokens|full|cost"
}
]
}
```
Gebruik dezelfde lijst `slash_commands` als Socket Mode hierboven, en voeg `"url": "https://gateway-host.example.com/slack/events"` toe aan elk item. Voorbeeld:
```json theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"slash_commands": [
{
"command": "/new",
"description": "Start a new session",
"usage_hint": "[model]",
"url": "https://gateway-host.example.com/slack/events"
},
{
"command": "/help",
"description": "Show the short help summary",
"url": "https://gateway-host.example.com/slack/events"
}
]
}
```
Herhaal die `url`-waarde voor elke opdracht in de lijst.
Voeg de botscope `chat:write.customize` toe als je wilt dat uitgaande berichten de actieve agentidentiteit gebruiken (aangepaste gebruikersnaam en pictogram) in plaats van de standaardidentiteit van de Slack-app.
Als je een emoji-pictogram gebruikt, verwacht Slack de syntaxis `:emoji_name:`.
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-zoekleesacties)
## Tokenmodel
* `botToken` + `appToken` zijn vereist voor Socket Mode.
* HTTP-modus vereist `botToken` + `signingSecret`.
* Relay-modus vereist `botToken` plus `relay.url`, `relay.authToken` en `relay.gatewayId`; deze gebruikt geen apptoken of ondertekeningsgeheim.
* `botToken`, `appToken`, `signingSecret`, `relay.authToken` en `userToken` accepteren plattetekststrings
of SecretRef-objecten.
* Configuratietokens overschrijven env-fallback.
* Env-fallback `SLACK_BOT_TOKEN` / `SLACK_APP_TOKEN` is alleen van toepassing op het standaardaccount.
* `userToken` is alleen configuratie (geen env-fallback) en gebruikt standaard alleen-lezen gedrag (`userTokenReadOnly: true`).
Gedrag van statussnapshot:
* Slack-accountinspectie houdt per referentie `*Source`- en `*Status`-velden bij
(`botToken`, `appToken`, `signingSecret`, `userToken`).
* Status is `available`, `configured_unavailable` of `missing`.
* `configured_unavailable` betekent dat het account is geconfigureerd via SecretRef
of een andere niet-inline geheime bron, maar dat het huidige opdracht-/runtimepad
de werkelijke waarde niet kon oplossen.
* In HTTP-modus wordt `signingSecretStatus` opgenomen; in Socket Mode is het
vereiste paar `botTokenStatus` + `appTokenStatus`.
Voor acties/directoryleesacties kan de voorkeur uitgaan naar een gebruikerstoken wanneer dit is geconfigureerd. Voor schrijfacties blijft het bottoken de voorkeur hebben; schrijven met gebruikerstoken is alleen toegestaan wanneer `userTokenReadOnly: false` en het bottoken niet beschikbaar is.
## Acties en poorten
Slack-acties worden beheerd door `channels.slack.actions.*`.
Beschikbare actiegroepen in de huidige Slack-tooling:
| Groep | Standaard |
| ---------- | ------------ |
| messages | ingeschakeld |
| reactions | ingeschakeld |
| pins | ingeschakeld |
| memberInfo | ingeschakeld |
| emojiList | ingeschakeld |
Huidige Slack-berichtacties omvatten `send`, `upload-file`, `download-file`, `read`, `edit`, `delete`, `pin`, `unpin`, `list-pins`, `member-info` en `emoji-list`. `download-file` accepteert Slack-bestands-ID's die in binnenkomende bestandsplaceholders worden weergegeven en retourneert afbeeldingsvoorbeelden voor afbeeldingen of lokale bestandsmetadata voor andere bestandstypen.
## Toegangscontrole en routering
`channels.slack.dmPolicy` regelt DM-toegang. `channels.slack.allowFrom` is de canonieke DM-allowlist.
* `pairing` (standaard)
* `allowlist`
* `open` (vereist dat `channels.slack.allowFrom` `"*"` bevat)
* `disabled`
DM-vlaggen:
* `dm.enabled` (standaard true)
* `channels.slack.allowFrom`
* `dm.allowFrom` (legacy)
* `dm.groupEnabled` (groeps-DM's standaard false)
* `dm.groupChannels` (optionele MPIM-allowlist)
Voorrangsregels voor meerdere accounts:
* `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 `channels.slack.accounts.default.allowFrom` niet.
Legacy `channels.slack.dm.policy` en `channels.slack.dm.allowFrom` worden voor compatibiliteit nog gelezen. `openclaw doctor --fix` migreert ze naar `dmPolicy` en `allowFrom` wanneer dat kan zonder de toegang te wijzigen.
Koppelen in DM's gebruikt `openclaw pairing approve slack `.
`channels.slack.groupPolicy` regelt kanaalafhandeling:
* `open`
* `allowlist`
* `disabled`
De kanaal-allowlist staat onder `channels.slack.channels` en **moet stabiele Slack-kanaal-ID's gebruiken** (bijvoorbeeld `C12345678`) als configuratiesleutels.
Runtime-opmerking: als `channels.slack` volledig ontbreekt (setup alleen via env), valt runtime terug op `groupPolicy="allowlist"` en logt een waarschuwing (zelfs als `channels.defaults.groupPolicy` is ingesteld).
Naam/ID-resolutie:
* kanaal-allowlistvermeldingen en DM-allowlistvermeldingen worden bij het opstarten resolved wanneer tokentoegang dit toestaat
* niet-resolved kanaalnaamvermeldingen blijven geconfigureerd, maar worden standaard genegeerd voor routering
* inkomende autorisatie en kanaalroutering zijn standaard ID-first; directe matching op gebruikersnaam/slug vereist `channels.slack.dangerouslyAllowNameMatching: true`
Op namen gebaseerde sleutels (`#channel-name` of `channel-name`) matchen **niet** onder `groupPolicy: "allowlist"`. De kanaalzoekactie is standaard ID-first, dus een op namen gebaseerde sleutel zal nooit succesvol routeren en alle berichten in dat kanaal worden stilzwijgend geblokkeerd. Dit verschilt van `groupPolicy: "open"`, waarbij de kanaalsleutel niet vereist is voor routering en een op namen gebaseerde sleutel lijkt te werken.
Gebruik altijd de Slack-kanaal-ID als sleutel. Zo vindt u die: klik met de rechtermuisknop op het kanaal in Slack → **Copy link** — de ID (`C...`) staat aan het einde van de URL.
Correct:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
groupPolicy: "allowlist",
channels: {
C12345678: { allow: true, requireMention: true },
},
},
},
}
```
Onjuist (stilzwijgend geblokkeerd onder `groupPolicy: "allowlist"`):
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
groupPolicy: "allowlist",
channels: {
"#eng-my-channel": { allow: true, requireMention: true },
},
},
},
}
```
Kanaalberichten vereisen standaard een vermelding.
Bronnen voor vermeldingen:
* expliciete app-vermelding (`<@botId>`)
* Slack-gebruikersgroepvermelding (``) wanneer de botgebruiker lid is van die gebruikersgroep; vereist `usergroups:read`
* regex-patronen voor vermeldingen (`agents.list[].groupChat.mentionPatterns`, fallback `messages.groupChat.mentionPatterns`)
* impliciet gedrag voor reply-to-bot-threads (uitgeschakeld wanneer `thread.requireExplicitMention` `true` is)
Besturing per kanaal (`channels.slack.channels.`; namen alleen via opstartresolutie of `dangerouslyAllowNameMatching`):
* `requireMention`
* `users` (allowlist)
* `allowBots`
* `skills`
* `systemPrompt`
* `tools`, `toolsBySender`
* sleutelindeling voor `toolsBySender`: `channel:`, `id:`, `e164:`, `username:`, `name:`, of wildcard `"*"`
(legacy sleutels zonder prefix worden nog steeds alleen naar `id:` gemapt)
`allowBots` is conservatief voor kanalen en privékanalen: door bots geschreven ruimteberichten worden alleen geaccepteerd wanneer de verzendende bot expliciet in de `users`-allowlist van die ruimte staat, of wanneer ten minste één expliciete Slack-eigenaar-ID uit `channels.slack.allowFrom` momenteel lid is van de ruimte. Wildcards en eigenaaritems op basis van weergavenaam voldoen niet aan aanwezigheid van een eigenaar. Aanwezigheid van een eigenaar gebruikt Slack `conversations.members`; zorg dat de app de bijpassende lees-scope heeft voor het ruimtetype (`channels:read` voor openbare kanalen, `groups:read` voor privékanalen). Als het opzoeken van leden mislukt, laat OpenClaw het door een bot geschreven ruimtebericht vallen.
Geaccepteerde door bots geschreven Slack-berichten gebruiken gedeelde [bot-loopbeveiliging](/nl/channels/bot-loop-protection). Configureer `channels.defaults.botLoopProtection` voor het standaardbudget en overschrijf daarna met `channels.slack.botLoopProtection` of `channels.slack.channels..botLoopProtection` wanneer een workspace of kanaal een andere limiet nodig heeft.
## Threads, sessies en antwoordtags
* DM's routeren als `direct`; kanalen als `channel`; MPIM's als `group`.
* Slack-routebindingen accepteren ruwe peer-ID's plus Slack-doelvormen zoals `channel:C12345678`, `user:U12345678` en `<@U12345678>`.
* Met de standaardinstelling `session.dmScope=main` vallen Slack-DM's samen in de hoofdsessie van de agent.
* Kanaalsessies: `agent::slack:channel:`.
* Gewone kanaalberichten op topniveau blijven op de sessie per kanaal, zelfs wanneer `replyToMode` niet `off` is.
* Slack-threadantwoorden gebruiken de bovenliggende Slack `thread_ts` voor sessiesuffixen (`:thread:`), zelfs wanneer uitgaande antwoordthreads zijn uitgeschakeld met `replyToMode="off"`.
* OpenClaw seedt een geschikte kanaalroot op topniveau in `agent::slack:channel::thread:` wanneer van die root wordt verwacht dat deze een zichtbare Slack-thread start, zodat de root en latere threadantwoorden één OpenClaw-sessie delen. Dit geldt voor `app_mention`-events, expliciete botmatches of geconfigureerde mention-pattern-matches, en kanalen met `requireMention: false` met een niet-`off` `replyToMode`.
* De standaardwaarde van `channels.slack.thread.historyScope` is `thread`; de standaardwaarde van `thread.inheritParent` is `false`.
* `channels.slack.thread.initialHistoryLimit` bepaalt hoeveel bestaande threadberichten worden opgehaald wanneer een nieuwe threadsessie start (standaard `20`; stel in op `0` om uit te schakelen).
* `channels.slack.thread.requireExplicitMention` (standaard `false`): wanneer `true`, onderdrukt dit impliciete threadmentions zodat de bot alleen reageert op expliciete `@bot`-mentions binnen threads, zelfs wanneer de bot al aan de thread heeft deelgenomen. Zonder dit omzeilen antwoorden in een thread waaraan de bot heeft deelgenomen de `requireMention`-poort.
Besturing van antwoordthreads:
* `channels.slack.replyToMode`: `off|first|all|batched` (standaard `off`)
* `channels.slack.replyToModeByChatType`: per `direct|group|channel`
* verouderde fallback voor directe chats: `channels.slack.dm.replyToMode`
Handmatige antwoordtags worden ondersteund:
* `[[reply_to_current]]`
* `[[reply_to:]]`
Voor expliciete Slack-threadantwoorden vanuit de `message`-tool stel je `replyBroadcast: true` in met `action: "send"` en `threadId` of `replyTo` om Slack te vragen het threadantwoord ook naar het bovenliggende kanaal te broadcasten. Dit wordt gekoppeld aan de Slack `chat.postMessage`-vlag `reply_broadcast` en wordt alleen ondersteund voor tekst- of Block Kit-verzendingen, niet voor media-uploads.
Wanneer een `message`-toolcall binnen een Slack-thread draait en hetzelfde kanaal target, erft OpenClaw normaal gesproken de huidige Slack-thread volgens `replyToMode`. Stel `topLevel: true` in op `action: "send"` of `action: "upload-file"` om in plaats daarvan een nieuw bericht in het bovenliggende kanaal af te dwingen. `threadId: null` wordt geaccepteerd als dezelfde opt-out naar topniveau.
`replyToMode="off"` schakelt uitgaande Slack-antwoordthreads uit, inclusief expliciete `[[reply_to_*]]`-tags. Het vlakt inkomende Slack-threadsessies niet af: berichten die al binnen een Slack-thread zijn geplaatst, routeren nog steeds naar de sessie `:thread:`. Dit verschilt van Telegram, waar expliciete tags nog steeds worden gehonoreerd in de modus `"off"`. Slack-threads verbergen berichten uit het kanaal, terwijl Telegram-antwoorden inline zichtbaar blijven.
## Ack-reacties
`ackReaction` verzendt een bevestigingsemoji terwijl OpenClaw een inkomend bericht verwerkt. `ackReactionScope` bepaalt *wanneer* die emoji daadwerkelijk wordt verzonden.
### Emoji (`ackReaction`)
Volgorde van resolutie:
* `channels.slack.accounts..ackReaction`
* `channels.slack.ackReaction`
* `messages.ackReaction`
* fallback naar emoji van agentidentiteit (`agents.list[].identity.emoji`, anders `"eyes"` / 👀)
Opmerkingen:
* Slack verwacht shortcodes (bijvoorbeeld `"eyes"`).
* Gebruik `""` om de reactie voor het Slack-account of globaal uit te schakelen.
### Scope (`messages.ackReactionScope`)
De Slack-provider leest de scope uit `messages.ackReactionScope` (standaard `"group-mentions"`). Er is vandaag geen override op Slack-account- of Slack-kanaalniveau; de waarde is globaal voor de Gateway.
Waarden:
* `"all"`: reageer in DM's en groepen.
* `"direct"`: reageer alleen in DM's.
* `"group-all"`: reageer op elk groepsbericht (geen DM's).
* `"group-mentions"` (standaard): reageer in groepen, maar alleen wanneer de bot wordt genoemd (of in groepsmentionables die zich hebben aangemeld). **DM's zijn uitgesloten.**
* `"off"` / `"none"`: reageer nooit.
De standaard-scope (`"group-mentions"`) activeert geen ack-reacties in directe berichten. Stel `messages.ackReactionScope` in op `"direct"` of `"all"` om de geconfigureerde `ackReaction` (bijvoorbeeld `"eyes"`) te zien op inkomende Slack-DM's. `messages.ackReactionScope` wordt gelezen bij het starten van de Slack-provider, dus een Gateway-herstart is nodig voordat de wijziging van kracht wordt.
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
messages: {
ackReaction: "eyes",
ackReactionScope: "all", // react in DMs and groups
},
}
```
## Tekststreaming
`channels.slack.streaming` bestuurt het gedrag van live previews:
* `off`: schakel live-previewstreaming uit.
* `partial` (standaard): vervang previewtekst door de nieuwste gedeeltelijke uitvoer.
* `block`: voeg preview-updates in chunks toe.
* `progress`: toon voortgangsstatustekst tijdens het genereren en verzend daarna de definitieve tekst.
* `streaming.preview.toolProgress`: wanneer conceptpreview actief is, routeer tool-/voortgangsupdates naar hetzelfde bewerkte previewbericht (standaard: `true`). Stel in op `false` om aparte tool-/voortgangsberichten te behouden.
* `streaming.preview.commandText` / `streaming.progress.commandText`: stel in op `status` om compacte tool-voortgangsregels te behouden terwijl ruwe command-/exec-tekst wordt verborgen (standaard: `raw`).
Verberg ruwe command-/exec-tekst terwijl compacte voortgangsregels behouden blijven:
```json theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
"channels": {
"slack": {
"streaming": {
"mode": "progress",
"progress": {
"toolProgress": true,
"commandText": "status"
}
}
}
}
}
```
`channels.slack.streaming.nativeTransport` bestuurt Slack-native tekststreaming wanneer `channels.slack.streaming.mode` `partial` is (standaard: `true`).
Slack-native taak-kaarten voor voortgang zijn opt-in voor de voortgangsmodus. Stel `channels.slack.streaming.progress.nativeTaskCards` in op `true` met `channels.slack.streaming.mode="progress"` om een Slack-native plan-/taakkaart te verzenden terwijl werk wordt uitgevoerd, en werk daarna dezelfde taakkaart bij bij voltooiing. Zonder deze vlag behoudt de voortgangsmodus het draagbare conceptpreviewgedrag.
* Er moet een antwoordthread beschikbaar zijn voordat native tekststreaming en Slack-assistentthreadstatus kunnen verschijnen. Threadselectie volgt nog steeds `replyToMode`.
* Kanaal-, groepschat- en DM-roots op topniveau kunnen nog steeds de normale conceptpreview gebruiken wanneer native streaming niet beschikbaar is of er geen antwoordthread bestaat.
* Slack-DM's op topniveau blijven standaard buiten threads, dus ze tonen Slack's native stream-/statuspreview in threadstijl niet; OpenClaw plaatst en bewerkt in plaats daarvan een conceptpreview in de DM.
* Media en niet-tekstpayloads vallen terug op normale levering.
* Definitieve media-/foutberichten annuleren wachtende previewbewerkingen; geschikte definitieve tekst-/blokberichten flushen alleen wanneer ze de preview op zijn plaats kunnen bewerken.
* Als streaming halverwege een antwoord mislukt, valt OpenClaw terug op normale levering voor resterende payloads.
Gebruik conceptpreview in plaats van Slack-native tekststreaming:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
streaming: {
mode: "partial",
nativeTransport: false,
},
},
},
}
```
Meld je aan voor Slack-native taak-kaarten voor voortgang:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
streaming: {
mode: "progress",
progress: {
nativeTaskCards: true,
render: "rich",
},
},
},
},
}
```
Verouderde sleutels:
* `channels.slack.streamMode` (`replace | status_final | append`) is een verouderde runtime-alias voor `channels.slack.streaming.mode`.
* boolean `channels.slack.streaming` is een verouderde runtime-alias voor `channels.slack.streaming.mode` en `channels.slack.streaming.nativeTransport`.
* verouderde `channels.slack.nativeStreaming` is een runtime-alias voor `channels.slack.streaming.nativeTransport`.
* Voer `openclaw doctor --fix` uit om opgeslagen Slack-streamingconfiguratie te herschrijven naar de canonieke sleutels.
## Fallback voor typreactie
`typingReaction` voegt een tijdelijke reactie toe aan het inkomende Slack-bericht terwijl OpenClaw een antwoord verwerkt, en verwijdert die wanneer de run eindigt. Dit is het nuttigst buiten threadantwoorden, die een standaardstatusindicator "is typing..." gebruiken.
Volgorde van resolutie:
* `channels.slack.accounts..typingReaction`
* `channels.slack.typingReaction`
Opmerkingen:
* Slack verwacht shortcodes (bijvoorbeeld `"hourglass_flowing_sand"`).
* De reactie is best-effort en opschonen wordt automatisch geprobeerd nadat het antwoord- of foutpad is voltooid.
## Media, chunking en levering
Slack-bestandsbijlagen worden gedownload van door Slack gehoste privé-URL's (token-geauthenticeerde requestflow) en naar de mediaopslag geschreven wanneer ophalen slaagt en groottebeperkingen dit toestaan. Bestandsplaceholders bevatten de Slack `fileId` zodat agents het oorspronkelijke bestand kunnen ophalen met `download-file`.
Downloads gebruiken begrensde idle- en totale time-outs. Als het ophalen van Slack-bestanden vastloopt of mislukt, blijft OpenClaw het bericht verwerken en valt het terug op de bestandsplaceholder.
De runtime-limiet voor inkomende grootte is standaard `20MB`, tenzij overschreven door `channels.slack.mediaMaxMb`.
* tekstchunks gebruiken `channels.slack.textChunkLimit` (standaard 4000)
* `channels.slack.chunkMode="newline"` schakelt splitsing per alinea eerst in
* bestandsverzendingen gebruiken Slack-upload-API's en kunnen threadantwoorden bevatten (`thread_ts`)
* de limiet voor uitgaande media volgt `channels.slack.mediaMaxMb` wanneer geconfigureerd; anders gebruiken kanaalverzendingen MIME-soortstandaarden uit de mediapijplijn
Voorkeursdoelen bij expliciete opgave:
* `user:` voor DM's
* `channel:` voor kanalen
Slack-DM's met alleen tekst/blokken kunnen rechtstreeks naar gebruikers-ID's posten; bestandsuploads en threadverzendingen openen eerst de DM via Slack-conversation-API's, omdat die paden een concreet conversation-ID vereisen.
## Commands en slashgedrag
Slashcommands verschijnen in Slack als één geconfigureerde command of als meerdere native commands. Configureer `channels.slack.slashCommand` om commandstandaarden te wijzigen:
* `enabled: false`
* `name: "openclaw"`
* `sessionPrefix: "slack:slash"`
* `ephemeral: true`
```txt theme={"theme":{"light":"min-light","dark":"min-dark"}}
/openclaw /help
```
Native commands vereisen [aanvullende manifestinstellingen](#additional-manifest-settings) in je Slack-app en worden in plaats daarvan ingeschakeld met `channels.slack.commands.native: true` of `commands.native: true` in globale configuraties.
* Native command-automodus staat **uit** voor Slack, dus `commands.native: "auto"` schakelt Slack-native commands niet in.
```txt theme={"theme":{"light":"min-light","dark":"min-dark"}}
/help
```
Native argumentmenu's gebruiken een adaptieve renderstrategie die een bevestigingsmodal toont voordat een geselecteerde optiewaarde wordt verzonden:
* tot 5 opties: button-blokken
* 6-100 opties: statisch selectiemenu
* meer dan 100 opties: externe selectie met asynchrone optiefiltering wanneer handlers voor interactiviteitsopties beschikbaar zijn
* overschreden Slack-limieten: gecodeerde optiewaarden vallen terug op buttons
```txt theme={"theme":{"light":"min-light","dark":"min-dark"}}
/think
```
Slash-sessies gebruiken geisoleerde sleutels zoals `agent::slack:slash:` en routeren opdrachtuitvoeringen nog steeds naar de doelgesprekssessie met `CommandTargetSessionKey`.
## Interactieve antwoorden
Slack kan door agents gemaakte interactieve antwoordknoppen weergeven, maar deze functie is standaard uitgeschakeld.
Voor nieuwe agent-, CLI- en Plugin-uitvoer geeft u de voorkeur aan de gedeelde
`presentation`-knoppen of selectieblokken. Ze gebruiken hetzelfde Slack-interactiepad
en degraderen tegelijk op andere kanalen.
Schakel dit globaal in:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
capabilities: {
interactiveReplies: true,
},
},
},
}
```
Of schakel dit alleen voor een Slack-account in:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
accounts: {
ops: {
capabilities: {
interactiveReplies: true,
},
},
},
},
},
}
```
Wanneer dit is ingeschakeld, kunnen agents nog steeds verouderde Slack-only antwoordrichtlijnen uitsturen:
* `[[slack_buttons: Approve:approve, Reject:reject]]`
* `[[slack_select: Choose a target | Canary:canary, Production:production]]`
Deze richtlijnen worden gecompileerd naar Slack Block Kit en routeren klikken of selecties
terug via het bestaande Slack-interactiegebeurtenispad. Behoud ze voor oude
prompts en Slack-specifieke uitwegen; gebruik gedeelde presentatie voor nieuwe
draagbare besturingselementen.
De API's van de richtlijncompiler zijn ook verouderd voor nieuwe producer-code:
* `compileSlackInteractiveReplies(...)`
* `parseSlackOptionsLine(...)`
* `isSlackInteractiveRepliesEnabled(...)`
* `buildSlackInteractiveBlocks(...)`
Gebruik `presentation`-payloads en `buildSlackPresentationBlocks(...)` voor nieuwe
door Slack weergegeven besturingselementen.
Opmerkingen:
* Dit is Slack-specifieke legacy-UI. Andere kanalen vertalen Slack Block
Kit-richtlijnen niet naar hun eigen knoppensystemen.
* De interactieve callbackwaarden zijn door OpenClaw gegenereerde ondoorzichtige tokens, geen ruwe door agents geschreven waarden.
* Als gegenereerde interactieve blokken de limieten van Slack Block Kit zouden overschrijden, valt OpenClaw terug op het oorspronkelijke tekstantwoord in plaats van een ongeldige blokkenpayload te verzenden.
### Modal-inzendingen die eigendom zijn van Plugins
Slack-plugins die een interactieve handler registreren, kunnen ook modal-
`view_submission`- en `view_closed`-levenscyclusgebeurtenissen ontvangen voordat OpenClaw
de payload compacter maakt voor de agent-zichtbare systeemgebeurtenis. Gebruik een van deze routeringspatronen
wanneer u een Slack-modal opent:
* Stel `callback_id` in op `openclaw::`.
* Of behoud een bestaande `callback_id` en plaats `pluginInteractiveData:
":"` in de modal-`private_metadata`.
De handler ontvangt `ctx.interaction.kind` als `view_submission` of
`view_closed`, genormaliseerde `inputs`, en het volledige ruwe `stateValues`-object van
Slack. Alleen-callback-id-routering is voldoende om de Plugin-handler aan te roepen; neem
de bestaande gebruikers-/sessierouteringsvelden van modal-`private_metadata` op wanneer de
modal ook een agent-zichtbare systeemgebeurtenis moet produceren. De agent ontvangt een
compacte, geredigeerde systeemgebeurtenis `Slack interaction: ...`. Als de handler
`systemEvent.summary`, `systemEvent.reference` of `systemEvent.data` retourneert, worden die
velden opgenomen in die compacte gebeurtenis, zodat de agent kan verwijzen naar
Plugin-eigen opslag zonder de volledige formulierpayload te zien.
## Native goedkeuringen in Slack
Slack kan fungeren als een native goedkeuringsclient met interactieve knoppen en interacties, in plaats van terug te vallen op de Web-UI of terminal.
* Exec- en Plugin-goedkeuringen kunnen worden weergegeven als Slack-native Block Kit-prompts.
* `channels.slack.execApprovals.*` blijft de configuratie voor inschakeling van de native exec-goedkeuringsclient en DM-/kanaalroutering.
* Exec-goedkeurings-DM's gebruiken `channels.slack.execApprovals.approvers` of `commands.ownerAllowFrom`.
* Plugin-goedkeuringen gebruiken Slack-native knoppen wanneer Slack is ingeschakeld als native goedkeuringsclient voor de oorspronkelijke sessie, of wanneer `approvals.plugin` routeert naar de oorspronkelijke Slack-sessie of een Slack-doel.
* Plugin-goedkeurings-DM's gebruiken Slack Plugin-goedkeurders uit `channels.slack.allowFrom`, `allowFrom` van een benoemd account, of de standaardroute van het account.
* Autorisatie van goedkeurders wordt nog steeds afgedwongen: goedkeurders voor alleen exec kunnen Plugin-aanvragen niet goedkeuren tenzij ze ook Plugin-goedkeurders zijn.
Dit gebruikt hetzelfde gedeelde goedkeuringsknoppenoppervlak als andere kanalen. Wanneer `interactivity` is ingeschakeld in de instellingen van uw Slack-app, worden goedkeuringsprompts rechtstreeks in het gesprek weergegeven als Block Kit-knoppen.
Wanneer die knoppen aanwezig zijn, zijn ze de primaire goedkeurings-UX; OpenClaw
mag alleen een handmatige `/approve`-opdracht opnemen wanneer het toolresultaat zegt dat chatgoedkeuringen
niet beschikbaar zijn of handmatige goedkeuring het enige pad is.
Configuratiepad:
* `channels.slack.execApprovals.enabled`
* `channels.slack.execApprovals.approvers` (optioneel; valt waar mogelijk terug op `commands.ownerAllowFrom`)
* `channels.slack.execApprovals.target` (`dm` | `channel` | `both`, standaard: `dm`)
* `agentFilter`, `sessionFilter`
Slack schakelt native exec-goedkeuringen automatisch in wanneer `enabled` niet is ingesteld of `"auto"` is en ten minste een
exec-goedkeurder wordt opgelost. Slack kan ook native Plugin-goedkeuringen via dit native-clientpad
afhandelen wanneer Slack Plugin-goedkeurders worden opgelost en de aanvraag overeenkomt met de native-clientfilters. Stel
`enabled: false` in om Slack expliciet uit te schakelen als native goedkeuringsclient. Stel `enabled: true` in om
native goedkeuringen te forceren wanneer goedkeurders worden opgelost. Het uitschakelen van Slack exec-goedkeuringen schakelt
native Slack Plugin-goedkeuringslevering die is ingeschakeld via `approvals.plugin` niet uit; Plugin-goedkeuringslevering
gebruikt in plaats daarvan Slack Plugin-goedkeurders.
Standaardgedrag zonder expliciete Slack exec-goedkeuringsconfiguratie:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
commands: {
ownerAllowFrom: ["slack:U12345678"],
},
}
```
Expliciete Slack-native configuratie is alleen nodig wanneer u goedkeurders wilt overschrijven, filters wilt toevoegen of
wilt kiezen voor levering in de oorspronkelijke chat:
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
channels: {
slack: {
execApprovals: {
enabled: true,
approvers: ["U12345678"],
target: "both",
},
},
},
}
```
Gedeelde `approvals.exec`-doorsturing is apart. Gebruik dit alleen wanneer exec-goedkeuringsprompts ook
naar andere chats of expliciete out-of-band-doelen moeten routeren. Gedeelde `approvals.plugin`-doorsturing is ook
apart; Slack-native levering onderdrukt die fallback alleen wanneer Slack de Plugin-
goedkeuringsaanvraag native kan afhandelen.
Same-chat `/approve` werkt ook in Slack-kanalen en DM's die al opdrachten ondersteunen. Zie [Exec-goedkeuringen](/nl/tools/exec-approvals) voor het volledige goedkeuringsdoorstuurmodel.
## Gebeurtenissen en operationeel gedrag
* Berichtbewerkingen/-verwijderingen worden omgezet naar systeemgebeurtenissen.
* Thread-broadcasts ("Also send to channel"-threadantwoorden) worden verwerkt als normale gebruikersberichten.
* Reactie-toevoegings-/verwijderingsgebeurtenissen worden omgezet naar systeemgebeurtenissen.
* Lid toetreden/verlaten, kanaal gemaakt/hernoemd, en pin toevoegen/verwijderen worden omgezet naar systeemgebeurtenissen.
* `channel_id_changed` kan kanaalconfiguratiesleutels migreren wanneer `configWrites` is ingeschakeld.
* Metadata voor kanaalonderwerp/-doel wordt behandeld als niet-vertrouwde context en kan in routeringscontext worden geinjecteerd.
* Threadstarter en initiale threadgeschiedenis-contextseeding worden gefilterd op geconfigureerde allowlists voor afzenders wanneer van toepassing.
* Blokacties, snelkoppelingen en modal-interacties zenden gestructureerde systeemgebeurtenissen `Slack interaction: ...` uit met rijke payloadvelden:
* blokacties: geselecteerde waarden, labels, pickerwaarden en `workflow_*`-metadata
* globale snelkoppelingen: callback- en actor-metadata, gerouteerd naar de directe sessie van de actor
* berichtsnelkoppelingen: callback-, actor-, kanaal-, thread- en geselecteerde-berichtcontext
* modal-`view_submission`- en `view_closed`-gebeurtenissen met gerouteerde kanaalmetadata en formulierinvoer
Definieer globale of berichtsnelkoppelingen in uw Slack-appconfiguratie en gebruik een niet-lege callback-ID. OpenClaw bevestigt overeenkomende snelkoppelingspayloads, past hetzelfde DM-/kanaalafzenderbeleid toe als andere Slack-interacties, en zet de opgeschoonde gebeurtenis in de wachtrij voor de gerouteerde agent-sessie. Trigger-ID's en antwoord-URL's worden uit agentcontext geredigeerd.
## Configuratiereferentie
Primaire referentie: [Configuratiereferentie - Slack](/nl/gateway/config-channels#slack).
* modus/auth: `mode`, `botToken`, `appToken`, `signingSecret`, `webhookPath`, `accounts.*`
* DM-toegang: `dm.enabled`, `dmPolicy`, `allowFrom` (legacy: `dm.policy`, `dm.allowFrom`), `dm.groupEnabled`, `dm.groupChannels`
* compatibiliteitsschakelaar: `dangerouslyAllowNameMatching` (noodrem; laat uit tenzij nodig)
* kanaaltoegang: `groupPolicy`, `channels.*`, `channels.*.users`, `channels.*.requireMention`
* threads/geschiedenis: `replyToMode`, `replyToModeByChatType`, `thread.*`, `historyLimit`, `dmHistoryLimit`, `dms.*.historyLimit`
* levering: `textChunkLimit`, `chunkMode`, `mediaMaxMb`, `streaming`, `streaming.nativeTransport`, `streaming.preview.toolProgress`
* unfurls: `unfurlLinks` (standaard: `false`), `unfurlMedia` voor beheer van link-/mediavoorvertoning in `chat.postMessage`; stel `unfurlLinks: true` in om opnieuw voor linkvoorvertoningen te kiezen
* ops/functies: `configWrites`, `commands.native`, `slashCommand.*`, `actions.*`, `userToken`, `userTokenReadOnly`
## Probleemoplossing
Controleer, in volgorde:
* `groupPolicy`
* kanaal-allowlist (`channels.slack.channels`) — **sleutels moeten kanaal-ID's zijn** (`C12345678`), geen namen (`#channel-name`). Op namen gebaseerde sleutels falen stil onder `groupPolicy: "allowlist"` omdat kanaalroutering standaard ID-first is. Een ID vinden: klik met rechts op het kanaal in Slack → **Copy link** — de `C...`-waarde aan het einde van de URL is de kanaal-ID.
* `requireMention`
* per-kanaal `users`-allowlist
* `messages.groupChat.visibleReplies`: normale groeps-/kanaalaanvragen hebben standaard `"automatic"`. Als u hebt gekozen voor `"message_tool"` en logs assistenttekst tonen zonder `message(action=send)`-aanroep, heeft het model het zichtbare message-toolpad gemist. Eindtekst blijft prive in deze modus; inspecteer de uitgebreide gateway-log op onderdrukte payloadmetadata, of stel dit in op `"automatic"` als u wilt dat elk normaal definitief assistentantwoord via het legacypad wordt geplaatst.
* `messages.groupChat.unmentionedInbound`: als dit `"room_event"` is, is niet-vermelde toegestane kanaalspraak omgevingscontext en blijft stil tenzij de agent de `message`-tool aanroept. Zie [Omgevingsruimtegebeurtenissen](/nl/channels/ambient-room-events).
```json5 theme={"theme":{"light":"min-light","dark":"min-dark"}}
{
messages: {
groupChat: {
visibleReplies: "automatic",
},
},
}
```
Nuttige opdrachten:
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
openclaw channels status --probe
openclaw logs --follow
openclaw doctor
```
Controleer:
* `channels.slack.dm.enabled`
* `channels.slack.dmPolicy` (of legacy `channels.slack.dm.policy`)
* koppelingsgoedkeuringen / allowlist-vermeldingen (`dmPolicy: "open"` vereist nog steeds `channels.slack.allowFrom: ["*"]`)
* groeps-DM's gebruiken MPIM-afhandeling; schakel `channels.slack.dm.groupEnabled` in en neem, indien geconfigureerd, de MPIM op in `channels.slack.dm.groupChannels`
* Slack Assistant-DM-gebeurtenissen: uitgebreide logs met `drop message_changed`
betekenen meestal dat Slack een bewerkte Assistant-threadgebeurtenis heeft gestuurd zonder een
herstelbare menselijke afzender in berichtmetadata
```bash theme={"theme":{"light":"min-light","dark":"min-dark"}}
openclaw pairing list slack
```
Valideer bot- en app-tokens en of Socket Mode is ingeschakeld in Slack-appinstellingen.
Het App-Level Token heeft `connections:write` nodig, en het Bot User OAuth Token-
bottoken moet bij dezelfde Slack-app/-workspace horen als het app-token.
Als `openclaw channels status --probe --json` `botTokenStatus` of
`appTokenStatus: "configured_unavailable"` toont, is het Slack-account
geconfigureerd, maar kon de huidige runtime de door SecretRef ondersteunde
waarde niet oplossen.
Logs zoals `slack socket mode failed to start; retry ...` zijn herstelbare
startfouten. Ontbrekende scopes, ingetrokken tokens en ongeldige authenticatie
mislukken in plaats daarvan direct. Een log `slack token mismatch ...` betekent
dat het bot-token en app-token bij verschillende Slack-apps lijken te horen;
herstel de Slack-appreferenties.
Valideer:
* signing secret
* Webhook-pad
* Slack Request URL's (Events + Interactivity + Slash Commands)
* unieke `webhookPath` per HTTP-account
* de openbare URL beëindigt TLS en stuurt verzoeken door naar het Gateway-pad
* het pad van de Slack-app `request_url` komt exact overeen met `channels.slack.webhookPath` (standaard `/slack/events`)
Als `signingSecretStatus: "configured_unavailable"` in accountsnapshots
verschijnt, is het HTTP-account geconfigureerd maar kon de huidige runtime
de door SecretRef ondersteunde signing secret niet oplossen.
Een herhaalde log `slack: webhook path ... already registered` betekent dat twee HTTP-
accounts dezelfde `webhookPath` gebruiken; geef elk account een afzonderlijk pad.
Controleer wat je bedoelde:
* native command-modus (`channels.slack.commands.native: true`) met bijpassende slash-commando's die in Slack zijn geregistreerd
* of single slash command-modus (`channels.slack.slashCommand.enabled: true`)
Slack maakt of verwijdert slash-commando's niet automatisch. `commands.native: "auto"` schakelt native Slack-commando's niet in; gebruik `true` en maak de bijpassende commando's in de Slack-app. In HTTP-modus moet elk Slack slash-commando de Gateway-URL bevatten. In Socket Mode komen command-payloads via de websocket binnen en negeert Slack `slash_commands[].url`.
Controleer ook `commands.useAccessGroups`, DM-autorisatie, kanaal-allowlists
en `users`-allowlists per kanaal. Slack retourneert tijdelijke fouten voor
geblokkeerde afzenders van slash-commando's, waaronder:
* `This channel is not allowed.`
* `You are not authorized to use this command here.`
## Referentie voor bijlage-vision
Slack kan gedownloade media aan de agentbeurt koppelen wanneer Slack-bestandsdownloads slagen en groottelimieten dit toestaan. Afbeeldingsbestanden kunnen via het media-understandingpad worden doorgegeven of rechtstreeks aan een antwoordmodel met vision-mogelijkheden; andere bestanden blijven behouden als downloadbare bestandscontext in plaats van als afbeeldingsinvoer te worden behandeld.
### Ondersteunde mediatypen
| Mediatype | Bron | Huidig gedrag | Opmerkingen |
| ------------------------------------ | --------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| JPEG / PNG / GIF / WebP-afbeeldingen | Slack-bestands-URL | Gedownload en aan de beurt gekoppeld voor verwerking met vision-mogelijkheden | Limiet per bestand: `channels.slack.mediaMaxMb` (standaard 20 MB) |
| PDF-bestanden | Slack-bestands-URL | Gedownload en beschikbaar gemaakt als bestandscontext voor tools zoals `download-file` of `pdf` | Inbound Slack converteert PDF's niet automatisch naar image-vision-invoer |
| Andere bestanden | Slack-bestands-URL | Waar mogelijk gedownload en beschikbaar gemaakt als bestandscontext | Binaire bestanden worden niet behandeld als afbeeldingsinvoer |
| Thread-antwoorden | Bestanden van threadstarter | Root-messagebestanden kunnen als context worden gehydrateerd wanneer het antwoord geen directe media heeft | Starters met alleen bestanden gebruiken een tijdelijke aanduiding voor bijlagen |
| Berichten met meerdere afbeeldingen | Meerdere Slack-bestanden | Elk bestand wordt onafhankelijk geëvalueerd | Slack-verwerking is beperkt tot acht bestanden per bericht |
### Inbound pipeline
Wanneer een Slack-bericht met bestandsbijlagen binnenkomt:
1. OpenClaw downloadt het bestand vanaf de privé-URL van Slack met het bot-token.
2. Het bestand wordt bij succes naar de mediaopslag geschreven.
3. Gedownloade mediapaden en inhoudstypen worden toegevoegd aan de inbound context.
4. Model-/toolpaden met afbeeldingsmogelijkheden kunnen afbeeldingsbijlagen uit die context gebruiken.
5. Niet-afbeeldingsbestanden blijven beschikbaar als bestandsmetadata of mediareferenties voor tools die ze kunnen verwerken.
### Overerving van bijlagen uit de thread-root
Wanneer een bericht in een thread binnenkomt (met een `thread_ts`-bovenliggend item):
* Als het antwoord zelf geen directe media heeft en het meegeleverde rootbericht bestanden heeft, kan Slack de rootbestanden hydrateren als thread-startercontext.
* Directe antwoordbijlagen hebben voorrang op bijlagen van het rootbericht.
* Een rootbericht dat alleen bestanden en geen tekst heeft, wordt weergegeven met een tijdelijke aanduiding voor bijlagen, zodat de fallback nog steeds de bestanden kan opnemen.
### Verwerking van meerdere bijlagen
Wanneer één Slack-bericht meerdere bestandsbijlagen bevat:
* Elke bijlage wordt onafhankelijk via de mediapijplijn verwerkt.
* Gedownloade mediareferenties worden samengevoegd in de berichtcontext.
* De verwerkingsvolgorde volgt de bestandsvolgorde van Slack in de gebeurtenispayload.
* Een fout bij het downloaden van één bijlage blokkeert de andere niet.
### Grootte-, download- en modellimieten
* **Groottelimiet**: standaard 20 MB per bestand. Configureerbaar via `channels.slack.mediaMaxMb`.
* **Downloadfouten**: bestanden die Slack niet kan leveren, verlopen URL's, ontoegankelijke bestanden, te grote bestanden en Slack-auth/login-HTML-responses worden overgeslagen in plaats van gerapporteerd als niet-ondersteunde formaten.
* **Vision-model**: afbeeldingsanalyse gebruikt het actieve antwoordmodel wanneer dit vision ondersteunt, of het afbeeldingsmodel dat is geconfigureerd op `agents.defaults.imageModel`.
### Bekende limieten
| Scenario | Huidig gedrag | Tijdelijke oplossing |
| ------------------------------------------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| Verlopen Slack-bestands-URL | Bestand overgeslagen; geen fout weergegeven | Upload het bestand opnieuw in Slack |
| Vision-model niet geconfigureerd | Afbeeldingsbijlagen worden opgeslagen als mediareferenties, maar niet als afbeeldingen geanalyseerd | Configureer `agents.defaults.imageModel` of gebruik een antwoordmodel met vision-mogelijkheden |
| Zeer grote afbeeldingen (> 20 MB standaard) | Overgeslagen volgens groottelimiet | Verhoog `channels.slack.mediaMaxMb` als Slack dit toestaat |
| Doorgestuurde/gedeelde bijlagen | Tekst en door Slack gehoste afbeeldings-/bestandsmedia zijn best-effort | Deel opnieuw rechtstreeks in de OpenClaw-thread |
| PDF-bijlagen | Opgeslagen als bestands-/mediacontext, niet automatisch via image vision gerouteerd | Gebruik `download-file` voor bestandsmetadata of de `pdf`-tool voor PDF-analyse |
### Gerelateerde documentatie
* [Media-understandingpipeline](/nl/nodes/media-understanding)
* [PDF-tool](/nl/tools/pdf)
* Epic: [#51349](https://github.com/openclaw/openclaw/issues/51349) — inschakeling van vision voor Slack-bijlagen
* Regressietests: [#51353](https://github.com/openclaw/openclaw/issues/51353)
* Live-verificatie: [#51354](https://github.com/openclaw/openclaw/issues/51354)
## Gerelateerd
Koppel een Slack-gebruiker aan de gateway.
Gedrag van kanalen en groeps-DM's.
Routeer inbound berichten naar agents.
Dreigingsmodel en hardening.
Config-indeling en prioriteit.
Commandocatalogus en gedrag.