Konfiguration – Kanäle

​

Channels

​

DM- und Gruppenzugriff

​

Channel-Modell-Overrides

{
  channels: {
    modelByChannel: {
      discord: {
        "123456789012345678": "anthropic/claude-opus-4-6",
      },
      slack: {
        C1234567890: "openai/gpt-5.5",
        "user:U12345": "openai/gpt-5.4-mini",
      },
      telegram: {
        "-1001234567890": "openai/gpt-5.4-mini",
        "-1001234567890:topic:99": "anthropic/claude-sonnet-4-6",
        "123456789": "openai/gpt-4.1",
      },
    },
  },
}

​

Channel-Standards und Heartbeat

{
  channels: {
    defaults: {
      groupPolicy: "allowlist", // open | allowlist | disabled
      contextVisibility: "all", // all | allowlist | allowlist_quote
      heartbeat: {
        showOk: false,
        showAlerts: true,
        useIndicator: true,
      },
    },
  },
}

• channels.defaults.groupPolicy: Fallback-Gruppenrichtlinie, wenn groupPolicy auf Provider-Ebene nicht gesetzt ist.
• channels.defaults.contextVisibility: Standardmodus für die Sichtbarkeit von ergänzendem Kontext für alle Channels. Werte: all (Standard, gesamten zitierten/Thread-/Verlaufskontext einschließen), allowlist (nur Kontext von Absendern in der Allowlist einschließen), allowlist_quote (wie Allowlist, aber expliziten Zitat-/Antwortkontext beibehalten). Per-Channel-Override: channels.<channel>.contextVisibility.
• channels.defaults.heartbeat.showOk: Gesunde Channel-Status in die Heartbeat-Ausgabe aufnehmen.
• channels.defaults.heartbeat.showAlerts: Eingeschränkte/Fehlerstatus in die Heartbeat-Ausgabe aufnehmen.
• channels.defaults.heartbeat.useIndicator: Kompakte Heartbeat-Ausgabe im Indikatorstil rendern.

​

WhatsApp

{
  web: {
    enabled: true,
    heartbeatSeconds: 60,
    whatsapp: {
      keepAliveIntervalMs: 25000,
      connectTimeoutMs: 60000,
      defaultQueryTimeoutMs: 60000,
    },
    reconnect: {
      initialMs: 2000,
      maxMs: 120000,
      factor: 1.4,
      jitter: 0.2,
      maxAttempts: 0,
    },
  },
  channels: {
    whatsapp: {
      dmPolicy: "pairing", // pairing | allowlist | open | disabled
      allowFrom: ["+15555550123", "+447700900123"],
      textChunkLimit: 4000,
      chunkMode: "length", // length | newline
      mediaMaxMb: 50,
      sendReadReceipts: true, // blue ticks (false in self-chat mode)
      groups: {
        "*": { requireMention: true },
      },
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15551234567"],
    },
  },
}

• Einträge in bindings[] auf oberster Ebene mit type: "acp" konfigurieren persistente ACP-Bindungen für WhatsApp-DMs und -Gruppen. Verwenden Sie eine direkte E.164-Nummer oder WhatsApp-Gruppen-JID in match.peer.id. Die Feldsemantik wird in ACP Agents gemeinsam beschrieben.

{
  channels: {
    whatsapp: {
      accounts: {
        default: {},
        personal: {},
        biz: {
          // authDir: "~/.openclaw/credentials/whatsapp/biz",
        },
      },
    },
  },
}

​

Telegram

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "your-bot-token",
      dmPolicy: "pairing",
      allowFrom: ["tg:123456789"],
      groups: {
        "*": { requireMention: true },
        "-1001234567890": {
          allowFrom: ["@admin"],
          systemPrompt: "Keep answers brief.",
          topics: {
            "99": {
              requireMention: false,
              skills: ["search"],
              systemPrompt: "Stay on topic.",
            },
          },
        },
      },
      customCommands: [
        { command: "backup", description: "Git backup" },
        { command: "generate", description: "Create an image" },
      ],
      historyLimit: 50,
      replyToMode: "first", // off | first | all | batched
      linkPreview: true,
      streaming: "partial", // off | partial | block | progress (default: partial)
      actions: { reactions: true, sendMessage: true },
      reactionNotifications: "own", // off | own | all
      mediaMaxMb: 100,
      retry: {
        attempts: 3,
        minDelayMs: 400,
        maxDelayMs: 30000,
        jitter: 0.1,
      },
      network: {
        autoSelectFamily: true,
        dnsResultOrder: "ipv4first",
      },
      apiRoot: "https://api.telegram.org",
      proxy: "socks5://localhost:9050",
      webhookUrl: "https://example.com/telegram-webhook",
      webhookSecret: "secret",
      webhookPath: "/telegram-webhook",
    },
  },
}

• Bot-Token: channels.telegram.botToken oder channels.telegram.tokenFile (nur reguläre Datei; Symlinks werden abgelehnt), mit TELEGRAM_BOT_TOKEN als Fallback für das Standardkonto.
• apiRoot ist nur der Root der Telegram Bot API. Verwenden Sie https://api.telegram.org oder Ihren selbst gehosteten/Proxy-Root, nicht https://api.telegram.org/bot<TOKEN>; openclaw doctor --fix entfernt ein versehentlich angehängtes Suffix /bot<TOKEN>.
• Optionales channels.telegram.defaultAccount überschreibt die Auswahl des Standardkontos, wenn es zu einer konfigurierten Konto-ID passt.
• Legen Sie in Multi-Account-Setups (2+ Konto-IDs) einen expliziten Standard fest (channels.telegram.defaultAccount oder channels.telegram.accounts.default), um Fallback-Routing zu vermeiden; openclaw doctor warnt, wenn dieser fehlt oder ungültig ist.
• configWrites: false blockiert von Telegram initiierte Konfigurationsschreibvorgänge (Supergroup-ID-Migrationen, /config set|unset).
• Einträge in bindings[] auf oberster Ebene mit type: "acp" konfigurieren persistente ACP-Bindungen für Forumsthemen (verwenden Sie das kanonische chatId:topic:topicId in match.peer.id). Die Feldsemantik wird in ACP Agents gemeinsam beschrieben.
• Telegram-Stream-Vorschauen verwenden sendMessage + editMessageText (funktioniert in direkten Chats und Gruppenchats).
• Wiederholungsrichtlinie: siehe Wiederholungsrichtlinie.

​

Discord

{
  channels: {
    discord: {
      enabled: true,
      token: "your-bot-token",
      mediaMaxMb: 100,
      allowBots: false,
      actions: {
        reactions: true,
        stickers: true,
        polls: true,
        permissions: true,
        messages: true,
        threads: true,
        pins: true,
        search: true,
        memberInfo: true,
        roleInfo: true,
        roles: false,
        channelInfo: true,
        voiceStatus: true,
        events: true,
        moderation: false,
      },
      replyToMode: "off", // off | first | all | batched
      dmPolicy: "pairing",
      allowFrom: ["1234567890", "123456789012345678"],
      dm: { enabled: true, groupEnabled: false, groupChannels: ["openclaw-dm"] },
      guilds: {
        "123456789012345678": {
          slug: "friends-of-openclaw",
          requireMention: false,
          ignoreOtherMentions: true,
          reactionNotifications: "own",
          users: ["987654321098765432"],
          channels: {
            general: { allow: true },
            help: {
              allow: true,
              requireMention: true,
              users: ["987654321098765432"],
              skills: ["docs"],
              systemPrompt: "Short answers only.",
            },
          },
        },
      },
      historyLimit: 20,
      textChunkLimit: 2000,
      suppressEmbeds: true,
      chunkMode: "length", // length | newline
      streaming: {
        mode: "progress", // off | partial | block | progress (Discord default: progress)
        progress: {
          label: "auto",
          maxLines: 8,
          maxLineChars: 120,
          toolProgress: true,
        },
      },
      maxLinesPerMessage: 17,
      ui: {
        components: {
          accentColor: "#5865F2",
        },
      },
      threadBindings: {
        enabled: true,
        idleHours: 24,
        maxAgeHours: 0,
        spawnSessions: true,
        defaultSpawnContext: "fork",
      },
      voice: {
        enabled: true,
        autoJoin: [
          {
            guildId: "123456789012345678",
            channelId: "234567890123456789",
          },
        ],
        daveEncryption: true,
        decryptionFailureTolerance: 24,
        connectTimeoutMs: 30000,
        reconnectGraceMs: 15000,
        tts: {
          provider: "openai",
          openai: { voice: "alloy" },
        },
      },
      execApprovals: {
        enabled: "auto", // true | false | "auto"
        approvers: ["987654321098765432"],
        agentFilter: ["default"],
        sessionFilter: ["discord:"],
        target: "dm", // dm | channel | both
        cleanupAfterResolve: false,
      },
      retry: {
        attempts: 3,
        minDelayMs: 500,
        maxDelayMs: 30000,
        jitter: 0.1,
      },
    },
  },
}

• Token: channels.discord.token, mit DISCORD_BOT_TOKEN als Fallback für das Standardkonto.
• Direkte ausgehende Aufrufe, die ein explizites Discord-token bereitstellen, verwenden dieses Token für den Aufruf; Einstellungen für Konto-Wiederholung und -Richtlinien stammen weiterhin aus dem ausgewählten Konto im aktiven Runtime-Snapshot.
• Optionales channels.discord.defaultAccount überschreibt die Auswahl des Standardkontos, wenn es mit einer konfigurierten Konto-ID übereinstimmt.
• Verwenden Sie user:<id> (DM) oder channel:<id> (Guild-Kanal) für Zustellziele; reine numerische IDs werden abgelehnt.
• Guild-Slugs sind kleingeschrieben, wobei Leerzeichen durch - ersetzt werden; Kanalschlüssel verwenden den slugifizierten Namen (kein #). Bevorzugen Sie Guild-IDs.
• Von Bots verfasste Nachrichten werden standardmäßig ignoriert. allowBots: true aktiviert sie; verwenden Sie allowBots: "mentions", um nur Bot-Nachrichten zu akzeptieren, die den Bot erwähnen (eigene Nachrichten werden weiterhin gefiltert).
• Kanäle, die von Bots verfasste eingehende Nachrichten unterstützen, können gemeinsamen Bot-Loop-Schutz verwenden. Setzen Sie channels.defaults.botLoopProtection für Basisbudgets für Paare und überschreiben Sie dann Kanal oder Konto nur, wenn eine Oberfläche andere Limits benötigt.
• channels.discord.guilds.<id>.ignoreOtherMentions (und Kanalüberschreibungen) verwirft Nachrichten, die einen anderen Benutzer oder eine Rolle erwähnen, aber nicht den Bot (ausgenommen @everyone/@here).
• channels.discord.mentionAliases ordnet stabilen ausgehenden @handle-Text vor dem Senden Discord-Benutzer-IDs zu, sodass bekannte Teammitglieder deterministisch erwähnt werden können, auch wenn der flüchtige Verzeichnis-Cache leer ist. Kontospezifische Überschreibungen befinden sich unter channels.discord.accounts.<accountId>.mentionAliases.
• maxLinesPerMessage (Standard 17) teilt hohe Nachrichten auch dann auf, wenn sie unter 2000 Zeichen liegen.
• channels.discord.suppressEmbeds ist standardmäßig true, sodass ausgehende URLs nicht zu Discord-Linkvorschauen erweitert werden, sofern dies nicht deaktiviert ist. Explizite embeds-Payloads werden weiterhin normal gesendet; Toolaufrufe pro Nachricht können dies mit suppressEmbeds überschreiben.
• channels.discord.threadBindings steuert Discord-threadgebundenes Routing:
  • enabled: Discord-Überschreibung für threadgebundene Sitzungsfunktionen (/focus, /unfocus, /agents, /session idle, /session max-age und gebundene Zustellung/Routing)
  • idleHours: Discord-Überschreibung für automatisches Unfocus bei Inaktivität in Stunden (0 deaktiviert)
  • maxAgeHours: Discord-Überschreibung für maximales Hartlimit-Alter in Stunden (0 deaktiviert)
  • spawnSessions: Schalter für sessions_spawn({ thread: true }) und automatische ACP-Thread-Erstellung/-Bindung bei Thread-Spawns (Standard: true)
  • defaultSpawnContext: nativer Subagent-Kontext für threadgebundene Spawns (standardmäßig "fork")
• Einträge auf oberster Ebene in bindings[] mit type: "acp" konfigurieren persistente ACP-Bindungen für Kanäle und Threads (Kanal-/Thread-ID in match.peer.id verwenden). Die Feldsemantik wird in ACP-Agenten gemeinsam genutzt.
• channels.discord.ui.components.accentColor legt die Akzentfarbe für Discord-Komponenten-v2-Container fest.
• channels.discord.agentComponents.ttlMs steuert, wie lange gesendete Discord-Komponenten-Callbacks registriert bleiben. Der Standardwert ist 1800000 (30 Minuten), das Maximum ist 86400000 (24 Stunden), und kontospezifische Überschreibungen befinden sich unter channels.discord.accounts.<accountId>.agentComponents.ttlMs. Längere Werte halten alte Buttons/Selects/Formulare länger nutzbar; bevorzugen Sie daher die kürzeste TTL, die zum Workflow passt.
• channels.discord.voice aktiviert Discord-Sprachkanal-Unterhaltungen und optionale Überschreibungen für Auto-Join + LLM + TTS. Reine Text-Discord-Konfigurationen lassen Voice standardmäßig deaktiviert; setzen Sie channels.discord.voice.enabled=true, um sich dafür zu entscheiden.
• channels.discord.voice.model überschreibt optional das LLM-Modell, das für Discord-Sprachkanal-Antworten verwendet wird.
• channels.discord.voice.daveEncryption und channels.discord.voice.decryptionFailureTolerance werden an die DAVE-Optionen von @discordjs/voice durchgereicht (standardmäßig true und 24).
• channels.discord.voice.connectTimeoutMs steuert das anfängliche @discordjs/voice-Warten auf Ready für /vc join und Auto-Join-Versuche (standardmäßig 30000).
• channels.discord.voice.reconnectGraceMs steuert, wie lange eine getrennte Voice-Sitzung Zeit hat, in die Wiederverbindungs-Signalisierung einzutreten, bevor OpenClaw sie zerstört (standardmäßig 15000).
• Die Discord-Voice-Wiedergabe wird nicht durch das Speaking-Start-Ereignis eines anderen Benutzers unterbrochen. Um Feedback-Schleifen zu vermeiden, ignoriert OpenClaw neue Voice-Erfassung, während TTS abgespielt wird.
• OpenClaw versucht zusätzlich, den Voice-Empfang wiederherzustellen, indem eine Voice-Sitzung nach wiederholten Entschlüsselungsfehlern verlassen und erneut betreten wird.
• channels.discord.streaming ist der kanonische Schlüssel für den Stream-Modus. Discord verwendet standardmäßig streaming.mode: "progress", sodass Tool-/Arbeitsfortschritt in einer bearbeiteten Vorschau-Nachricht erscheint; setzen Sie streaming.mode: "off", um dies zu deaktivieren. Legacy-Werte streamMode und boolesche streaming-Werte bleiben Runtime-Aliasse; führen Sie openclaw doctor --fix aus, um persistierte Konfiguration neu zu schreiben.
• channels.discord.autoPresence ordnet Runtime-Verfügbarkeit der Bot-Präsenz zu (healthy => online, degraded => idle, exhausted => dnd) und erlaubt optionale Überschreibungen des Statustexts.
• channels.discord.dangerouslyAllowNameMatching aktiviert veränderliches Name-/Tag-Matching erneut (Notfall-Kompatibilitätsmodus).
• channels.discord.execApprovals: Discord-native Zustellung von Exec-Genehmigungen und Autorisierung der Genehmigenden.
  • enabled: true, false oder "auto" (Standard). Im Auto-Modus werden Exec-Genehmigungen aktiviert, wenn Genehmigende aus approvers oder commands.ownerAllowFrom aufgelöst werden können.
  • approvers: Discord-Benutzer-IDs, die Exec-Anfragen genehmigen dürfen. Fällt bei Auslassung auf commands.ownerAllowFrom zurück.
  • agentFilter: optionale Allowlist für Agent-IDs. Weglassen, um Genehmigungen für alle Agenten weiterzuleiten.
  • sessionFilter: optionale Sitzungsschlüssel-Muster (Teilzeichenfolge oder Regex).
  • target: wohin Genehmigungsaufforderungen gesendet werden. "dm" (Standard) sendet an DMs der Genehmigenden, "channel" sendet an den Ursprungskanal, "both" sendet an beide. Wenn das Ziel "channel" enthält, sind Buttons nur für aufgelöste Genehmigende nutzbar.
  • cleanupAfterResolve: löscht bei true Genehmigungs-DMs nach Genehmigung, Ablehnung oder Timeout.

​

Google Chat

{
  channels: {
    googlechat: {
      enabled: true,
      serviceAccountFile: "/path/to/service-account.json",
      audienceType: "app-url", // app-url | project-number
      audience: "https://gateway.example.com/googlechat",
      webhookPath: "/googlechat",
      botUser: "users/1234567890",
      dm: {
        enabled: true,
        policy: "pairing",
        allowFrom: ["users/1234567890"],
      },
      groupPolicy: "allowlist",
      groups: {
        "spaces/AAAA": { allow: true, requireMention: true },
      },
      actions: { reactions: true },
      typingIndicator: "message",
      mediaMaxMb: 20,
    },
  },
}

• Dienstkonto-JSON: inline (serviceAccount) oder dateibasiert (serviceAccountFile).
• Dienstkonto-SecretRef wird ebenfalls unterstützt (serviceAccountRef).
• Env-Fallbacks: GOOGLE_CHAT_SERVICE_ACCOUNT oder GOOGLE_CHAT_SERVICE_ACCOUNT_FILE.
• Verwenden Sie spaces/<spaceId> oder users/<userId> für Zustellziele.
• channels.googlechat.dangerouslyAllowNameMatching aktiviert veränderliches E-Mail-Principal-Matching erneut (Notfall-Kompatibilitätsmodus).

​

Slack

{
  channels: {
    slack: {
      enabled: true,
      botToken: "xoxb-...",
      appToken: "xapp-...",
      socketMode: {
        clientPingTimeout: 15000,
        serverPingTimeout: 30000,
        pingPongLoggingEnabled: false,
      },
      dmPolicy: "pairing",
      allowFrom: ["U123", "U456", "*"],
      dm: { enabled: true, groupEnabled: false, groupChannels: ["G123"] },
      channels: {
        C123: { allow: true, requireMention: true, allowBots: false },
        "#general": {
          allow: true,
          requireMention: true,
          allowBots: false,
          users: ["U123"],
          skills: ["docs"],
          systemPrompt: "Short answers only.",
        },
      },
      historyLimit: 50,
      allowBots: false,
      reactionNotifications: "own",
      reactionAllowlist: ["U123"],
      replyToMode: "off", // off | first | all | batched
      thread: {
        historyScope: "thread", // thread | channel
        inheritParent: false,
      },
      actions: {
        reactions: true,
        messages: true,
        pins: true,
        memberInfo: true,
        emojiList: true,
      },
      slashCommand: {
        enabled: true,
        name: "openclaw",
        sessionPrefix: "slack:slash",
        ephemeral: true,
      },
      typingReaction: "hourglass_flowing_sand",
      unfurlLinks: false,
      unfurlMedia: false,
      textChunkLimit: 4000,
      chunkMode: "length",
      streaming: {
        mode: "partial", // off | partial | block | progress
        nativeTransport: true, // use Slack native streaming API when mode=partial
      },
      mediaMaxMb: 20,
      execApprovals: {
        enabled: "auto", // true | false | "auto"
        approvers: ["U123"],
        agentFilter: ["default"],
        sessionFilter: ["slack:"],
        target: "dm", // dm | channel | both
      },
    },
  },
}

• Socket-Modus erfordert sowohl botToken als auch appToken (SLACK_BOT_TOKEN + SLACK_APP_TOKEN als Env-Fallback für das Standardkonto).
• HTTP-Modus erfordert botToken plus signingSecret (auf Root-Ebene oder pro Konto).
• socketMode reicht Slack-SDK-Transport-Tuning für Socket Mode an die öffentliche Bolt-Receiver-API durch. Verwenden Sie es nur, wenn Sie Ping/Pong-Timeouts oder veraltetes Websocket-Verhalten untersuchen. clientPingTimeout ist standardmäßig 15000; serverPingTimeout und pingPongLoggingEnabled werden nur durchgereicht, wenn sie konfiguriert sind.
• botToken, appToken, signingSecret und userToken akzeptieren Klartext- Strings oder SecretRef-Objekte.
• Slack-Konto-Snapshots stellen Quell-/Statusfelder pro Anmeldeinformation bereit, etwa botTokenSource, botTokenStatus, appTokenStatus und im HTTP-Modus signingSecretStatus. configured_unavailable bedeutet, dass das Konto über SecretRef konfiguriert ist, der aktuelle Befehls-/Laufzeitpfad den Secret-Wert aber nicht auflösen konnte.
• configWrites: false blockiert von Slack ausgelöste Config-Schreibvorgänge.
• Das optionale channels.slack.defaultAccount überschreibt die Standardkontoauswahl, wenn es mit einer konfigurierten Konto-ID übereinstimmt.
• channels.slack.streaming.mode ist der kanonische Schlüssel für den Slack-Stream-Modus. channels.slack.streaming.nativeTransport steuert Slacks nativen Streaming-Transport. Legacy-Werte für streamMode, boolesches streaming und nativeStreaming bleiben Laufzeit-Aliasse; führen Sie openclaw doctor --fix aus, um persistierte Config umzuschreiben.
• unfurlLinks und unfurlMedia reichen Slacks chat.postMessage-Booleans für Link- und Medien-Unfurling bei Bot-Antworten durch. unfurlLinks ist standardmäßig false, damit ausgehende Bot-Links nicht inline erweitert werden, sofern dies nicht aktiviert ist; unfurlMedia wird ausgelassen, sofern es nicht konfiguriert ist. Setzen Sie einen der Werte unter channels.slack.accounts.<accountId>, um den Top-Level-Wert für ein Konto zu überschreiben.
• Verwenden Sie user:<id> (DM) oder channel:<id> für Zustellungsziele.

• Slack Native Streaming plus der Slack-Assistenten-artige Thread-Status „tippt …“ erfordern ein Antwort-Thread-Ziel. Top-Level-DMs bleiben standardmäßig außerhalb von Threads, sodass sie weiterhin über Slack-Entwurfsbeiträge mit Bearbeitungsvorschau streamen können, statt die native Stream-/Statusvorschau im Thread-Stil anzuzeigen.
• typingReaction fügt der eingehenden Slack-Nachricht eine temporäre Reaktion hinzu, während eine Antwort läuft, und entfernt sie nach Abschluss. Verwenden Sie einen Slack-Emoji-Shortcode wie "hourglass_flowing_sand".
• channels.slack.execApprovals: Slack-native Zustellung über Approval-Client und Autorisierung von Exec-Genehmigern. Gleiches Schema wie Discord: enabled (true/false/"auto"), approvers (Slack-Benutzer-IDs), agentFilter, sessionFilter und target ("dm", "channel" oder "both"). Plugin-Genehmigungen können diesen nativen Client-Pfad für von Slack stammende Anfragen verwenden, wenn Slack-Plugin-Genehmiger aufgelöst werden; Slack-native Zustellung von Plugin-Genehmigungen kann auch über approvals.plugin für von Slack stammende Sitzungen oder Slack-Ziele aktiviert werden. Plugin-Genehmigungen verwenden Slack-Plugin-Genehmiger aus allowFrom und Standard-Routing, nicht Exec-Genehmiger.

​

Mattermost

{
  channels: {
    mattermost: {
      enabled: true,
      botToken: "mm-token",
      baseUrl: "https://chat.example.com",
      dmPolicy: "pairing",
      chatmode: "oncall", // oncall | onmessage | onchar
      oncharPrefixes: [">", "!"],
      groups: {
        "*": { requireMention: true },
        "team-channel-id": { requireMention: false },
      },
      commands: {
        native: true, // opt-in
        nativeSkills: true,
        callbackPath: "/api/channels/mattermost/command",
        // Optional explicit URL for reverse-proxy/public deployments
        callbackUrl: "https://gateway.example.com/api/channels/mattermost/command",
      },
      textChunkLimit: 4000,
      chunkMode: "length",
    },
  },
}

• commands.callbackPath muss ein Pfad sein (zum Beispiel /api/channels/mattermost/command), keine vollständige URL.
• commands.callbackUrl muss zum OpenClaw-Gateway-Endpunkt auflösen und vom Mattermost-Server erreichbar sein.
• Native Slash-Callbacks werden mit den pro Befehl zurückgegebenen Tokens authentifiziert, die Mattermost während der Registrierung von Slash-Befehlen zurückgibt. Wenn die Registrierung fehlschlägt oder keine Befehle aktiviert sind, weist OpenClaw Callbacks mit Unauthorized: invalid command token. zurück.
• Für private/Tailnet/interne Callback-Hosts kann Mattermost erfordern, dass ServiceSettings.AllowedUntrustedInternalConnections den Callback-Host bzw. die Domain enthält. Verwenden Sie Host-/Domain-Werte, keine vollständigen URLs.
• channels.mattermost.configWrites: von Mattermost ausgelöste Config-Schreibvorgänge erlauben oder verweigern.
• channels.mattermost.requireMention: @mention vor Antworten in Kanälen verlangen.
• channels.mattermost.groups.<channelId>.requireMention: kanalbezogene Überschreibung für Erwähnungs-Gating ("*" als Standard).
• Das optionale channels.mattermost.defaultAccount überschreibt die Standardkontoauswahl, wenn es mit einer konfigurierten Konto-ID übereinstimmt.

​

Signal

{
  channels: {
    signal: {
      enabled: true,
      account: "+15555550123", // optional account binding
      dmPolicy: "pairing",
      allowFrom: ["+15551234567", "uuid:123e4567-e89b-12d3-a456-426614174000"],
      configWrites: true,
      reactionNotifications: "own", // off | own | all | allowlist
      reactionAllowlist: ["+15551234567", "uuid:123e4567-e89b-12d3-a456-426614174000"],
      historyLimit: 50,
    },
  },
}

• channels.signal.account: Kanalstart an eine bestimmte Signal-Kontoidentität binden.
• channels.signal.configWrites: von Signal ausgelöste Config-Schreibvorgänge erlauben oder verweigern.
• Das optionale channels.signal.defaultAccount überschreibt die Standardkontoauswahl, wenn es mit einer konfigurierten Konto-ID übereinstimmt.

​

iMessage

{
  channels: {
    imessage: {
      enabled: true,
      cliPath: "imsg",
      dbPath: "~/Library/Messages/chat.db",
      remoteHost: "user@gateway-host",
      dmPolicy: "pairing",
      allowFrom: ["+15555550123", "user@example.com", "chat_id:123"],
      historyLimit: 50,
      includeAttachments: false,
      attachmentRoots: ["/Users/*/Library/Messages/Attachments"],
      remoteAttachmentRoots: ["/Users/*/Library/Messages/Attachments"],
      mediaMaxMb: 16,
      service: "auto",
      sendTransport: "auto",
      region: "US",
      actions: {
        reactions: true,
        edit: true,
        unsend: true,
        reply: true,
        sendWithEffect: true,
        sendAttachment: true,
      },
    },
  },
}

• Das optionale channels.imessage.defaultAccount überschreibt die Standardkontoauswahl, wenn es mit einer konfigurierten Konto-ID übereinstimmt.
• Erfordert vollständigen Festplattenzugriff auf die Messages-DB.
• Bevorzugen Sie chat_id:<id>-Ziele. Verwenden Sie imsg chats --limit 20, um Chats aufzulisten.
• cliPath kann auf einen SSH-Wrapper verweisen; setzen Sie remoteHost (host oder user@host) für das Abrufen von Anhängen per SCP.
• attachmentRoots und remoteAttachmentRoots beschränken eingehende Anhangspfade (Standard: /Users/*/Library/Messages/Attachments).
• SCP verwendet strikte Host-Key-Prüfung; stellen Sie daher sicher, dass der Relay-Host-Key bereits in ~/.ssh/known_hosts vorhanden ist.
• channels.imessage.configWrites: von iMessage ausgelöste Config-Schreibvorgänge erlauben oder verweigern.
• channels.imessage.sendTransport: bevorzugter imsg-RPC-Sendetransport für normale ausgehende Antworten. auto (Standard) verwendet die IMCore-Bridge für vorhandene Chats, wenn sie läuft, und fällt dann auf AppleScript zurück; bridge erfordert Zustellung über private API; applescript erzwingt den öffentlichen Messages-Automation-Pfad.
• channels.imessage.actions.*: private API-Aktionen aktivieren, die auch durch imsg status / openclaw channels status --probe gegatet sind.
• channels.imessage.includeAttachments ist standardmäßig deaktiviert; setzen Sie es auf true, bevor Sie eingehende Medien in Agent-Turns erwarten.
• Eingehende Wiederherstellung nach einem Bridge-/Gateway-Neustart erfolgt automatisch (GUID-Deduplizierung plus Altersgrenze für veralteten Backlog). Vorhandene channels.imessage.catchup.enabled: true-Configs werden weiterhin als veraltetes Kompatibilitätsprofil berücksichtigt.
• channels.imessage.groups: Gruppenregistrierung und gruppenbezogene Einstellungen. Mit groupPolicy: "allowlist" konfigurieren Sie entweder explizite chat_id-Schlüssel oder einen "*"-Wildcard-Eintrag, damit Gruppennachrichten das Registry-Gate passieren können.
• Top-Level-bindings[]-Einträge mit type: "acp" können iMessage-Unterhaltungen an persistente ACP-Sitzungen binden. Verwenden Sie ein normalisiertes Handle oder ein explizites Chat-Ziel (chat_id:*, chat_guid:*, chat_identifier:*) in match.peer.id. Gemeinsame Feldsemantik: ACP-Agenten.

#!/usr/bin/env bash
exec ssh -T gateway-host imsg "$@"

​

Matrix

{
  channels: {
    matrix: {
      enabled: true,
      homeserver: "https://matrix.example.org",
      accessToken: "syt_bot_xxx",
      proxy: "http://127.0.0.1:7890",
      encryption: true,
      initialSyncLimit: 20,
      defaultAccount: "ops",
      accounts: {
        ops: {
          name: "Ops",
          userId: "@ops:example.org",
          accessToken: "syt_ops_xxx",
        },
        alerts: {
          userId: "@alerts:example.org",
          password: "secret",
          proxy: "http://127.0.0.1:7891",
        },
      },
    },
  },
}

• Token-Auth verwendet accessToken; Passwort-Auth verwendet userId + password.
• channels.matrix.proxy leitet Matrix-HTTP-Traffic über einen expliziten HTTP(S)-Proxy. Benannte Konten können dies mit channels.matrix.accounts.<id>.proxy überschreiben.
• channels.matrix.network.dangerouslyAllowPrivateNetwork erlaubt private/interne Homeserver. proxy und dieses Netzwerk-Opt-in sind unabhängige Steuerungen.
• channels.matrix.defaultAccount wählt das bevorzugte Konto in Setups mit mehreren Konten aus.
• channels.matrix.autoJoin ist standardmäßig off, sodass eingeladene Räume und neue DM-artige Einladungen ignoriert werden, bis Sie autoJoin: "allowlist" mit autoJoinAllowlist oder autoJoin: "always" setzen.
• channels.matrix.execApprovals: Matrix-native Zustellung von Exec-Genehmigungen und Autorisierung von Genehmigenden.
  • enabled: true, false oder "auto" (Standard). Im Auto-Modus werden Exec-Genehmigungen aktiviert, wenn Genehmigende aus approvers oder commands.ownerAllowFrom aufgelöst werden können.
  • approvers: Matrix-Benutzer-IDs (z. B. @owner:example.org), die Exec-Anfragen genehmigen dürfen.
  • agentFilter: optionale Agent-ID-Allowlist. Weglassen, um Genehmigungen für alle Agenten weiterzuleiten.
  • sessionFilter: optionale Session-Key-Muster (Teilzeichenfolge oder Regex).
  • target: wohin Genehmigungsaufforderungen gesendet werden. "dm" (Standard), "channel" (ursprünglicher Raum) oder "both".
  • Überschreibungen pro Konto: channels.matrix.accounts.<id>.execApprovals.
• channels.matrix.dm.sessionScope steuert, wie Matrix-DMs zu Sessions gruppiert werden: per-user (Standard) teilt nach geroutetem Peer, während per-room jeden DM-Raum isoliert.
• Matrix-Statusprüfungen und Live-Verzeichnis-Lookups verwenden dieselbe Proxy-Richtlinie wie Runtime-Traffic.
• Die vollständige Matrix-Konfiguration, Targeting-Regeln und Setup-Beispiele sind in Matrix dokumentiert.

​

Microsoft Teams

{
  channels: {
    msteams: {
      enabled: true,
      configWrites: true,
      // appId, appPassword, tenantId, webhook, team/channel policies:
      // see /channels/msteams
    },
  },
}

• Hier abgedeckte zentrale Schlüsselpfade: channels.msteams, channels.msteams.configWrites.
• Die vollständige Teams-Konfiguration (Anmeldedaten, Webhook, DM-/Gruppenrichtlinie, Überschreibungen pro Team/pro Kanal) ist in Microsoft Teams dokumentiert.

​

IRC

{
  channels: {
    irc: {
      enabled: true,
      dmPolicy: "pairing",
      configWrites: true,
      nickserv: {
        enabled: true,
        service: "NickServ",
        password: "${IRC_NICKSERV_PASSWORD}",
        register: false,
        registerEmail: "bot@example.com",
      },
    },
  },
}

• Hier abgedeckte zentrale Schlüsselpfade: channels.irc, channels.irc.dmPolicy, channels.irc.configWrites, channels.irc.nickserv.*.
• Optionales channels.irc.defaultAccount überschreibt die Standardkontoauswahl, wenn es mit einer konfigurierten Konto-ID übereinstimmt.
• Die vollständige IRC-Kanalkonfiguration (Host/Port/TLS/Kanäle/Allowlists/Erwähnungs-Gating) ist in IRC dokumentiert.

​

Mehrere Konten (alle Kanäle)

{
  channels: {
    telegram: {
      accounts: {
        default: {
          name: "Primary bot",
          botToken: "123456:ABC...",
        },
        alerts: {
          name: "Alerts bot",
          botToken: "987654:XYZ...",
        },
      },
    },
  },
}

• default wird verwendet, wenn accountId weggelassen wird (CLI + Routing).
• Env-Tokens gelten nur für das Standardkonto.
• Basis-Kanaleinstellungen gelten für alle Konten, sofern sie nicht pro Konto überschrieben werden.
• Verwenden Sie bindings[].match.accountId, um jedes Konto an einen anderen Agenten zu routen.
• Wenn Sie ein Nicht-Standardkonto über openclaw channels add (oder Kanal-Onboarding) hinzufügen, während noch eine Top-Level-Kanalkonfiguration für ein einzelnes Konto verwendet wird, verschiebt OpenClaw zuerst kontobezogene Top-Level-Werte für Einzelkonten in die Konten-Map des Kanals, damit das ursprüngliche Konto weiter funktioniert. Die meisten Kanäle verschieben sie nach channels.<channel>.accounts.default; Matrix kann stattdessen ein vorhandenes übereinstimmendes benanntes/Standardziel beibehalten.
• Bestehende kanalbezogene Bindings (ohne accountId) passen weiterhin zum Standardkonto; kontobezogene Bindings bleiben optional.
• openclaw doctor --fix repariert gemischte Formen ebenfalls, indem kontobezogene Top-Level-Werte für Einzelkonten in das für diesen Kanal ausgewählte hochgestufte Konto verschoben werden. Die meisten Kanäle verwenden accounts.default; Matrix kann stattdessen ein vorhandenes übereinstimmendes benanntes/Standardziel beibehalten.

​

Andere Plugin-Kanäle

​

Erwähnungs-Gating in Gruppenchats

• Metadaten-Erwähnungen: Native Plattform-@Erwähnungen. Im WhatsApp-Self-Chat-Modus ignoriert.
• Textmuster: Sichere Regex-Muster in agents.list[].groupChat.mentionPatterns. Ungültige Muster und unsichere verschachtelte Wiederholungen werden ignoriert.
• Erwähnungs-Gating wird nur erzwungen, wenn Erkennung möglich ist (native Erwähnungen oder mindestens ein Muster).

{
  messages: {
    visibleReplies: "automatic", // force old automatic final replies for direct/source chats
    groupChat: {
      historyLimit: 50,
      unmentionedInbound: "room_event", // always-on unmentioned room chatter becomes quiet context
      visibleReplies: "message_tool", // opt-in; require message(action=send) for visible room replies
    },
  },
  agents: {
    list: [{ id: "main", groupChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
  },
}

​

DM-Verlaufslimits

{
  channels: {
    telegram: {
      dmHistoryLimit: 30,
      dms: {
        "123456789": { historyLimit: 50 },
      },
    },
  },
}

​

Self-Chat-Modus

{
  channels: {
    whatsapp: {
      allowFrom: ["+15555550123"],
      groups: { "*": { requireMention: true } },
    },
  },
  agents: {
    list: [
      {
        id: "main",
        groupChat: { mentionPatterns: ["reisponde", "@openclaw"] },
      },
    ],
  },
}

​

Befehle (Chat-Befehlsverarbeitung)

{
  commands: {
    native: "auto", // register native commands when supported
    nativeSkills: "auto", // register native skill commands when supported
    text: true, // parse /commands in chat messages
    bash: false, // allow ! (alias: /bash)
    bashForegroundMs: 2000,
    config: false, // allow /config
    mcp: false, // allow /mcp
    plugins: false, // allow /plugins
    debug: false, // allow /debug
    restart: true, // allow /restart + gateway restart tool
    ownerAllowFrom: ["discord:123456789012345678"],
    ownerDisplay: "raw", // raw | hash
    ownerDisplaySecret: "${OWNER_ID_HASH_SECRET}",
    allowFrom: {
      "*": ["user1"],
      discord: ["user:123"],
    },
    useAccessGroups: true,
  },
}

​

Verwandte Themen

• Konfigurationsreferenz — Schlüssel auf oberster Ebene
• Konfiguration — Agents
• Kanalübersicht