Slack

Status: Produktionsreif für DMs + Kanäle via Slack-App-Integrationen. Standardmodus ist Socket Mode; HTTP Events API-Modus wird ebenfalls unterstützt.

• Pairing — Slack-DMs verwenden standardmäßig den Pairing-Modus.
• Slash-Befehle — Natives Befehlsverhalten und Befehlskatalog.
• Kanal-Fehlerbehebung — Kanalübergreifende Diagnose- und Reparatur-Playbooks.

Schnelleinrichtung

Socket Mode (Standard)

  ### Schritt 1: Slack-App und Tokens erstellen
    In den Slack-App-Einstellungen:

    - **Socket Mode** aktivieren
    - **App Token** erstellen (`xapp-...`) mit `connections:write`
    - App installieren und **Bot Token** kopieren (`xoxb-...`)


  ### Schritt 2: OpenClaw konfigurieren

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

    Umgebungsvariablen-Fallback (nur Standardkonto):

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

  ### Schritt 3: App-Events abonnieren
    Bot-Events abonnieren für:

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

    Außerdem den App Home **Messages Tab** für DMs aktivieren.


  ### Schritt 4: Gateway starten

openclaw gateway

HTTP Events API-Modus

  ### Schritt 1: Slack-App für HTTP konfigurieren

    - Modus auf HTTP setzen (`channels.slack.mode="http"`)
    - Slack **Signing Secret** kopieren
    - Event Subscriptions + Interactivity + Slash Command Request-URL auf denselben Webhook-Pfad setzen (Standard `/slack/events`)



  ### Schritt 2: OpenClaw HTTP-Modus konfigurieren

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

  ### Schritt 3: Eindeutige Webhook-Pfade für Multi-Account-HTTP verwenden
    Pro-Konto-HTTP-Modus wird unterstützt.

    Gib jedem Konto einen eigenen `webhookPath`, damit Registrierungen nicht kollidieren.

Token-Modell

• botToken + appToken sind für Socket Mode erforderlich.
• HTTP-Modus erfordert botToken + signingSecret.
• Konfigurations-Tokens überschreiben Umgebungsvariablen-Fallbacks.
• SLACK_BOT_TOKEN / SLACK_APP_TOKEN Umgebungsvariablen-Fallback gilt nur für das Standardkonto.
• userToken (xoxp-...) ist nur in der Konfiguration verfügbar (kein Umgebungsvariablen-Fallback) und verhält sich standardmäßig schreibgeschützt (userTokenReadOnly: true).
• Optional: chat:write.customize hinzufügen, wenn ausgehende Nachrichten die aktive Agent-Identität verwenden sollen (benutzerdefinierter username und Icon). icon_emoji verwendet die :emoji_name:-Syntax.

Tipp: Für Aktionen/Verzeichnislesevorgänge kann das User Token bevorzugt werden, wenn konfiguriert. Für Schreibvorgänge bleibt das Bot Token bevorzugt; User-Token-Schreibvorgänge sind nur erlaubt, wenn userTokenReadOnly: false ist und kein Bot Token verfügbar ist.

Zugriffssteuerung und Routing

DM-Richtlinie

`channels.slack.dmPolicy` steuert den DM-Zugriff (Legacy: `channels.slack.dm.policy`):

- `pairing` (Standard)
- `allowlist`
- `open` (erfordert, dass `channels.slack.allowFrom` `"*"` enthält; Legacy: `channels.slack.dm.allowFrom`)
- `disabled`

DM-Flags:

- `dm.enabled` (Standard true)
- `channels.slack.allowFrom` (bevorzugt)
- `dm.allowFrom` (Legacy)
- `dm.groupEnabled` (Gruppen-DMs Standard false)
- `dm.groupChannels` (optionale MPIM-Allowlist)

Multi-Account-Vorrang:

- `channels.slack.accounts.default.allowFrom` gilt nur für das `default`-Konto.
- Benannte Konten erben `channels.slack.allowFrom`, wenn ihr eigenes `allowFrom` nicht gesetzt ist.
- Benannte Konten erben nicht `channels.slack.accounts.default.allowFrom`.

Pairing in DMs verwendet `openclaw pairing approve slack <code>`.

Kanalrichtlinie

`channels.slack.groupPolicy` steuert die Kanalbehandlung:

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

Die Kanal-Allowlist befindet sich unter `channels.slack.channels` und sollte stabile Kanal-IDs verwenden.

Laufzeithinweis: Wenn `channels.slack` vollständig fehlt (reines Umgebungsvariablen-Setup), fällt die Laufzeit auf `groupPolicy="allowlist"` zurück und protokolliert eine Warnung (auch wenn `channels.defaults.groupPolicy` gesetzt ist).

Name/ID-Auflösung:

- Kanal-Allowlist-Einträge und DM-Allowlist-Einträge werden beim Start aufgelöst, wenn der Token-Zugriff dies erlaubt
- nicht aufgelöste Kanalnamen-Einträge werden wie konfiguriert beibehalten, aber standardmäßig beim Routing ignoriert
- eingehende Autorisierung und Kanal-Routing sind standardmäßig ID-first; direktes Benutzername-/Slug-Matching erfordert `channels.slack.dangerouslyAllowNameMatching: true`

Erwähnungen und Kanalbenutzer

Kanalnachrichten sind standardmäßig durch Erwähnungen geschützt.

Erwähnungsquellen:

- explizite App-Erwähnung (`<@botId>`)
- Erwähnungsmuster (`agents.list[].groupChat.mentionPatterns`, Fallback `messages.groupChat.mentionPatterns`)
- implizites Reply-to-Bot-Thread-Verhalten

Pro-Kanal-Steuerungen (`channels.slack.channels.<id>`; Namen nur über Startauflösung oder `dangerouslyAllowNameMatching`):

- `requireMention`
- `users` (Allowlist)
- `allowBots`
- `skills`
- `systemPrompt`
- `tools`, `toolsBySender`
- `toolsBySender`-Schlüsselformat: `id:`, `e164:`, `username:`, `name:` oder `"*"` Wildcard
  (Legacy-Schlüssel ohne Präfix werden weiterhin nur auf `id:` abgebildet)

Befehle und Slash-Verhalten

• Nativer Befehlsautomodus ist für Slack deaktiviert (commands.native: "auto" aktiviert keine nativen Slack-Befehle).
• Aktiviere native Slack-Befehlshandler mit channels.slack.commands.native: true (oder global commands.native: true).
• Wenn native Befehle aktiviert sind, registriere passende Slash-Befehle in Slack (/<command>-Namen), mit einer Ausnahme:
  • registriere /agentstatus für den Status-Befehl (Slack reserviert /status)
• Wenn native Befehle nicht aktiviert sind, kannst du einen einzelnen konfigurierten Slash-Befehl über channels.slack.slashCommand ausführen.
• Native Argument-Menüs passen ihre Darstellungsstrategie jetzt an:
  • bis zu 5 Optionen: Button-Blöcke
  • 6-100 Optionen: statisches Select-Menü
  • mehr als 100 Optionen: externes Select mit asynchroner Optionsfilterung, wenn Interaktivitäts-Optionshandler verfügbar sind
  • wenn kodierte Optionswerte Slack-Limits überschreiten, fällt der Ablauf auf Buttons zurück
• Für lange Options-Payloads verwenden Slash-Befehl-Argument-Menüs einen Bestätigungsdialog vor dem Absenden eines ausgewählten Werts.

Interaktive Antworten

Slack kann vom Agenten erstellte interaktive Antwortsteuerungen rendern, aber diese Funktion ist standardmäßig deaktiviert.

Global aktivieren:

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

Oder nur für ein Slack-Konto aktivieren:

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

Wenn aktiviert, können Agenten Slack-spezifische Antwortdirektiven ausgeben:

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

Diese Direktiven werden in Slack Block Kit kompiliert und leiten Klicks oder Auswahlen über den bestehenden Slack-Interaktions-Event-Pfad zurück.

Hinweise:

• Dies ist Slack-spezifische UI. Andere Kanäle übersetzen Slack Block Kit-Direktiven nicht in ihre eigenen Button-Systeme.
• Die interaktiven Callback-Werte sind von OpenClaw generierte undurchsichtige Tokens, keine rohen, vom Agenten verfassten Werte.
• Wenn generierte interaktive Blöcke die Slack Block Kit-Limits überschreiten würden, fällt OpenClaw auf die ursprüngliche Textantwort zurück, anstatt einen ungültigen Blocks-Payload zu senden.

Standard-Slash-Befehl-Einstellungen:

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

Slash-Sessions verwenden isolierte Schlüssel:

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

und leiten die Befehlsausführung weiterhin gegen die Zielkonversations-Session (CommandTargetSessionKey) weiter.

Threading, Sessions und Antwort-Tags

• DMs werden als direct geroutet; Kanäle als channel; MPIMs als group.
• Bei Standard session.dmScope=main werden Slack-DMs zur Agent-Hauptsession zusammengefasst.
• Kanal-Sessions: agent:<agentId>:slack:channel:<channelId>.
• Thread-Antworten können Thread-Session-Suffixe erstellen (:thread:<threadTs>), wenn zutreffend.
• channels.slack.thread.historyScope Standard ist thread; thread.inheritParent Standard ist false.
• channels.slack.thread.initialHistoryLimit steuert, wie viele bestehende Thread-Nachrichten beim Start einer neuen Thread-Session abgerufen werden (Standard 20; 0 zum Deaktivieren).

Antwort-Threading-Steuerungen:

• channels.slack.replyToMode: off|first|all (Standard off)
• channels.slack.replyToModeByChatType: pro direct|group|channel
• Legacy-Fallback für Direkt-Chats: channels.slack.dm.replyToMode

Manuelle Antwort-Tags werden unterstützt:

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

Hinweis: replyToMode="off" deaktiviert alles Antwort-Threading in Slack, einschließlich expliziter [[reply_to_*]]-Tags. Dies unterscheidet sich von Telegram, wo explizite Tags auch im "off"-Modus weiterhin berücksichtigt werden. Der Unterschied spiegelt die Plattform-Threading-Modelle wider: Slack-Threads verbergen Nachrichten aus dem Kanal, während Telegram-Antworten im Hauptchat-Verlauf sichtbar bleiben.

Medien, Chunking und Zustellung

Slack-Dateianhänge werden von Slack-gehosteten privaten URLs heruntergeladen (token-authentifizierter Anfrage-Ablauf) und in den Medienspeicher geschrieben, wenn der Abruf erfolgreich ist und Größenlimits dies erlauben.

Die Laufzeit-Eingangs-Größenbegrenzung ist standardmäßig `20MB`, sofern nicht durch `channels.slack.mediaMaxMb` überschrieben.

- Text-Chunks verwenden `channels.slack.textChunkLimit` (Standard 4000)
- `channels.slack.chunkMode="newline"` aktiviert Absatz-first-Splitting
- Dateisendungen verwenden Slack-Upload-APIs und können Thread-Antworten enthalten (`thread_ts`)
- die ausgehende Medien-Obergrenze folgt `channels.slack.mediaMaxMb`, wenn konfiguriert; andernfalls verwenden Kanalsendungen MIME-Typ-Standards aus der Medien-Pipeline

Bevorzugte explizite Ziele:

- `user:<id>` für DMs
- `channel:<id>` für Kanäle

Slack-DMs werden über Slack-Konversations-APIs geöffnet, wenn an Benutzerziele gesendet wird.

Aktionen und Gates

Slack-Aktionen werden durch channels.slack.actions.* gesteuert.

Verfügbare Aktionsgruppen im aktuellen Slack-Tooling:

Events und Betriebsverhalten

• Nachrichtenbearbeitungen/-löschungen/Thread-Broadcasts werden auf Systemevents abgebildet.
• Reaktions-Hinzufügen/-Entfernen-Events werden auf Systemevents abgebildet.
• Mitglied-Beitritt/-Austritt, Kanal-Erstellt/-Umbenannt und Pin-Hinzufügen/-Entfernen-Events werden auf Systemevents abgebildet.
• Assistenten-Thread-Status-Updates (für „tippt…”-Indikatoren in Threads) verwenden assistant.threads.setStatus und erfordern den Bot-Scope assistant:write.
• channel_id_changed kann Kanal-Konfigurationsschlüssel migrieren, wenn configWrites aktiviert ist.
• Kanal-Topic/Zweck-Metadaten werden als nicht vertrauenswürdiger Kontext behandelt und können in den Routing-Kontext injiziert werden.
• Block-Aktionen und Modal-Interaktionen emittieren strukturierte Slack interaction: ...-Systemevents mit umfangreichen Payload-Feldern:
  • Block-Aktionen: ausgewählte Werte, Labels, Picker-Werte und workflow_*-Metadaten
  • Modal view_submission- und view_closed-Events mit geroutetem Kanal-Metadaten und Formulareingaben

Ack-Reaktionen

ackReaction sendet ein Bestätigungs-Emoji, während OpenClaw eine eingehende Nachricht verarbeitet.

Auflösungsreihenfolge:

• channels.slack.accounts.<accountId>.ackReaction
• channels.slack.ackReaction
• messages.ackReaction
• Agent-Identitäts-Emoji-Fallback (agents.list[].identity.emoji, sonst ”👀”)

Hinweise:

• Slack erwartet Shortcodes (zum Beispiel "eyes").
• Verwende "", um die Reaktion für das Slack-Konto oder global zu deaktivieren.

Tipp-Reaktions-Fallback

typingReaction fügt der eingehenden Slack-Nachricht eine temporäre Reaktion hinzu, während OpenClaw eine Antwort verarbeitet, und entfernt sie, wenn der Durchlauf abgeschlossen ist. Dies ist ein nützlicher Fallback, wenn Slack-natives Assistenten-Tippen nicht verfügbar ist, besonders in DMs.

Auflösungsreihenfolge:

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

Hinweise:

• Slack erwartet Shortcodes (zum Beispiel "hourglass_flowing_sand").
• Die Reaktion ist Best-Effort und die Bereinigung wird automatisch nach dem Antwort- oder Fehlerpfad versucht.

Manifest und Scope-Checkliste

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

Wenn du `channels.slack.userToken` konfigurierst, sind typische Lese-Scopes:

- `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` (wenn du auf Slack-Suchlese angewiesen bist)

Fehlerbehebung

Prüfe in dieser Reihenfolge:

- `groupPolicy`
- Kanal-Allowlist (`channels.slack.channels`)
- `requireMention`
- Pro-Kanal-`users`-Allowlist

Nützliche Befehle:

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

Prüfe:

- `channels.slack.dm.enabled`
- `channels.slack.dmPolicy` (oder Legacy `channels.slack.dm.policy`)
- Pairing-Genehmigungen / Allowlist-Einträge

openclaw pairing list slack

Überprüfe Bot- + App-Tokens und die Socket Mode-Aktivierung in den Slack-App-Einstellungen.

Überprüfe:

- Signing Secret
- Webhook-Pfad
- Slack Request-URLs (Events + Interactivity + Slash Commands)
- eindeutiger `webhookPath` pro HTTP-Konto

Prüfe, ob du Folgendes beabsichtigt hast:

- nativer Befehlsmodus (`channels.slack.commands.native: true`) mit passenden Slash-Befehlen, die in Slack registriert sind
- oder Einzelner-Slash-Befehl-Modus (`channels.slack.slashCommand.enabled: true`)

Prüfe auch `commands.useAccessGroups` und Kanal-/Benutzer-Allowlists.

Text-Streaming

OpenClaw unterstützt natives Slack-Text-Streaming über die Agents and AI Apps API.

channels.slack.streaming steuert das Live-Preview-Verhalten:

• off: Live-Preview-Streaming deaktivieren.
• partial (Standard): Preview-Text durch die neueste Teilausgabe ersetzen.
• block: Chunked Preview-Updates anhängen.
• progress: Fortschrittsstatus-Text während der Generierung anzeigen, dann endgültigen Text senden.

channels.slack.nativeStreaming steuert Slacks native Streaming-API (chat.startStream / chat.appendStream / chat.stopStream), wenn streaming partial ist (Standard: true).

Natives Slack-Streaming deaktivieren (Draft-Preview-Verhalten beibehalten):

channels:
  slack:
    streaming: partial
    nativeStreaming: false

Legacy-Schlüssel:

• channels.slack.streamMode (replace | status_final | append) wird automatisch zu channels.slack.streaming migriert.
• boolesches channels.slack.streaming wird automatisch zu channels.slack.nativeStreaming migriert.

Anforderungen

1. Agents and AI Apps in deinen Slack-App-Einstellungen aktivieren.
2. Sicherstellen, dass die App den Scope assistant:write hat.
3. Ein Antwort-Thread muss für diese Nachricht verfügbar sein. Die Thread-Auswahl folgt weiterhin replyToMode.

Verhalten

• Erster Text-Chunk startet einen Stream (chat.startStream).
• Spätere Text-Chunks werden an denselben Stream angehängt (chat.appendStream).
• Ende der Antwort finalisiert den Stream (chat.stopStream).
• Medien und Nicht-Text-Payloads fallen auf normale Zustellung zurück.
• Wenn Streaming mitten in der Antwort fehlschlägt, fällt OpenClaw für verbleibende Payloads auf normale Zustellung zurück.

Konfigurationsreferenz

Primäre Referenz:

• Configuration reference - Slack

  Wichtige Slack-Felder:

  • Modus/Auth: mode, botToken, appToken, signingSecret, webhookPath, accounts.*
  • DM-Zugriff: dm.enabled, dmPolicy, allowFrom (Legacy: dm.policy, dm.allowFrom), dm.groupEnabled, dm.groupChannels
  • Kompatibilitätsschalter: dangerouslyAllowNameMatching (Notfall; deaktiviert lassen, wenn nicht benötigt)
  • Kanalzugriff: groupPolicy, channels.*, channels.*.users, channels.*.requireMention
  • Threading/History: replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
  • Zustellung: textChunkLimit, chunkMode, mediaMaxMb, streaming, nativeStreaming
  • Betrieb/Features: configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

Verwandte Dokumentation

• Pairing
• Channel routing
• Troubleshooting
• Configuration
• Slash commands