Configuration — canaux

​

Canaux

​

Accès DM et groupe

​

Remplacements de modèle par canal

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

​

Valeurs par défaut des canaux et Heartbeat

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

• channels.defaults.groupPolicy : politique de groupe de repli lorsqu’un groupPolicy au niveau fournisseur n’est pas défini.
• channels.defaults.contextVisibility : mode de visibilité du contexte supplémentaire par défaut pour tous les canaux. Valeurs : all (par défaut, inclure tout le contexte cité/de fil/d’historique), allowlist (inclure uniquement le contexte des expéditeurs autorisés), allowlist_quote (identique à allowlist mais conserve le contexte explicite de citation/réponse). Remplacement par canal : channels.<channel>.contextVisibility.
• channels.defaults.heartbeat.showOk : inclure les statuts de canal sains dans la sortie Heartbeat.
• channels.defaults.heartbeat.showAlerts : inclure les statuts dégradés/en erreur dans la sortie Heartbeat.
• channels.defaults.heartbeat.useIndicator : afficher une sortie Heartbeat compacte de type indicateur.

​

WhatsApp

{
  channels: {
    whatsapp: {
      dmPolicy: "pairing", // pairing | allowlist | open | disabled
      allowFrom: ["+15555550123", "+447700900123"],
      textChunkLimit: 4000,
      chunkMode: "length", // length | newline
      mediaMaxMb: 50,
      sendReadReceipts: true, // coches bleues (false en mode discussion avec soi-même)
      groups: {
        "*": { requireMention: true },
      },
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15551234567"],
    },
  },
  web: {
    enabled: true,
    heartbeatSeconds: 60,
    reconnect: {
      initialMs: 2000,
      maxMs: 120000,
      factor: 1.4,
      jitter: 0.2,
      maxAttempts: 0,
    },
  },
}

{
  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: off; activation explicite pour éviter les limites de débit des modifications d’aperçu)
      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",
      },
      proxy: "socks5://localhost:9050",
      webhookUrl: "https://example.com/telegram-webhook",
      webhookSecret: "secret",
      webhookPath: "/telegram-webhook",
    },
  },
}

• Jeton du bot : channels.telegram.botToken ou channels.telegram.tokenFile (fichier ordinaire uniquement ; liens symboliques rejetés), avec TELEGRAM_BOT_TOKEN comme repli pour le compte par défaut.
• channels.telegram.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• Dans les configurations multi-comptes (2+ ID de compte), définissez un défaut explicite (channels.telegram.defaultAccount ou channels.telegram.accounts.default) pour éviter le routage de repli ; openclaw doctor avertit lorsque cela est absent ou invalide.
• configWrites: false bloque les écritures de configuration initiées par Telegram (migrations d’ID de supergroupe, /config set|unset).
• Les entrées bindings[] de niveau supérieur avec type: "acp" configurent des liaisons ACP persistantes pour les topics de forum (utilisez le format canonique chatId:topic:topicId dans match.peer.id). La sémantique des champs est partagée dans Agents ACP.
• Les aperçus de streaming Telegram utilisent sendMessage + editMessageText (fonctionne dans les discussions directes et de groupe).
• Politique de nouvelle tentative : voir Politique de nouvelle tentative.

​

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,
      chunkMode: "length", // length | newline
      streaming: "off", // off | partial | block | progress (progress correspond à partial sur Discord)
      maxLinesPerMessage: 17,
      ui: {
        components: {
          accentColor: "#5865F2",
        },
      },
      threadBindings: {
        enabled: true,
        idleHours: 24,
        maxAgeHours: 0,
        spawnSubagentSessions: false, // activation explicite pour sessions_spawn({ thread: true })
      },
      voice: {
        enabled: true,
        autoJoin: [
          {
            guildId: "123456789012345678",
            channelId: "234567890123456789",
          },
        ],
        daveEncryption: true,
        decryptionFailureTolerance: 24,
        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,
      },
    },
  },
}

• Jeton : channels.discord.token, avec DISCORD_BOT_TOKEN comme repli pour le compte par défaut.
• Les appels sortants directs qui fournissent un token Discord explicite utilisent ce jeton pour l’appel ; les paramètres de politique/nouvelle tentative du compte proviennent toujours du compte sélectionné dans l’instantané runtime actif.
• channels.discord.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• Utilisez user:<id> (DM) ou channel:<id> (canal de serveur) pour les cibles de livraison ; les ID numériques bruts sont rejetés.
• Les slugs de serveur sont en minuscules avec les espaces remplacés par - ; les clés de canal utilisent le nom slugifié (sans #). Préférez les ID de serveur.
• Les messages rédigés par des bots sont ignorés par défaut. allowBots: true les active ; utilisez allowBots: "mentions" pour n’accepter que les messages de bot qui mentionnent le bot (les propres messages restent filtrés).
• channels.discord.guilds.<id>.ignoreOtherMentions (et les remplacements de canal) supprime les messages qui mentionnent un autre utilisateur ou rôle mais pas le bot (hors @everyone/@here).
• maxLinesPerMessage (17 par défaut) découpe les messages hauts même lorsqu’ils font moins de 2000 caractères.
• channels.discord.threadBindings contrôle le routage lié aux fils Discord :
  • enabled : remplacement Discord pour les fonctionnalités de session liées aux fils (/focus, /unfocus, /agents, /session idle, /session max-age, ainsi que la livraison/le routage liés)
  • idleHours : remplacement Discord pour le désancrage automatique sur inactivité en heures (0 désactive)
  • maxAgeHours : remplacement Discord pour l’âge maximal strict en heures (0 désactive)
  • spawnSubagentSessions : activation explicite pour la création/liaison automatique de fil par sessions_spawn({ thread: true })
• Les entrées bindings[] de niveau supérieur avec type: "acp" configurent des liaisons ACP persistantes pour les canaux et les fils (utilisez l’ID de canal/fil dans match.peer.id). La sémantique des champs est partagée dans Agents ACP.
• channels.discord.ui.components.accentColor définit la couleur d’accentuation pour les conteneurs Discord components v2.
• channels.discord.voice active les conversations dans les canaux vocaux Discord et les remplacements facultatifs d’auto-connexion + TTS.
• channels.discord.voice.daveEncryption et channels.discord.voice.decryptionFailureTolerance sont transmis aux options DAVE de @discordjs/voice (true et 24 par défaut).
• OpenClaw tente en plus une récupération de réception vocale en quittant/rejoignant une session vocale après des échecs répétés de déchiffrement.
• channels.discord.streaming est la clé canonique du mode de streaming. Les anciennes valeurs streamMode et booléennes streaming sont migrées automatiquement.
• channels.discord.autoPresence mappe la disponibilité runtime à la présence du bot (sain => online, dégradé => idle, épuisé => dnd) et autorise des remplacements facultatifs du texte de statut.
• channels.discord.dangerouslyAllowNameMatching réactive la correspondance mutable par nom/tag (mode de compatibilité de dernier recours).
• channels.discord.execApprovals : livraison native Discord des approbations exec et autorisation des approbateurs.
  • enabled : true, false ou "auto" (par défaut). En mode auto, les approbations exec s’activent lorsque les approbateurs peuvent être résolus à partir de approvers ou commands.ownerAllowFrom.
  • approvers : ID utilisateur Discord autorisés à approuver les demandes exec. Revient à commands.ownerAllowFrom lorsqu’il est omis.
  • agentFilter : liste d’autorisation facultative des ID d’agent. Omettez pour transférer les approbations pour tous les agents.
  • sessionFilter : motifs facultatifs de clé de session (sous-chaîne ou regex).
  • target : où envoyer les invites d’approbation. "dm" (par défaut) les envoie dans les DM des approbateurs, "channel" les envoie dans le canal d’origine, "both" les envoie aux deux. Lorsque la cible inclut "channel", les boutons ne sont utilisables que par les approbateurs résolus.
  • cleanupAfterResolve : lorsque true, supprime les DM d’approbation après approbation, refus ou expiration.

​

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,
    },
  },
}

• JSON du compte de service : inline (serviceAccount) ou basé sur un fichier (serviceAccountFile).
• SecretRef de compte de service également pris en charge (serviceAccountRef).
• Variables d’environnement de repli : GOOGLE_CHAT_SERVICE_ACCOUNT ou GOOGLE_CHAT_SERVICE_ACCOUNT_FILE.
• Utilisez spaces/<spaceId> ou users/<userId> pour les cibles de livraison.
• channels.googlechat.dangerouslyAllowNameMatching réactive la correspondance mutable par principal d’e-mail (mode de compatibilité de dernier recours).

​

Slack

{
  channels: {
    slack: {
      enabled: true,
      botToken: "xoxb-...",
      appToken: "xapp-...",
      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",
      textChunkLimit: 4000,
      chunkMode: "length",
      streaming: {
        mode: "partial", // off | partial | block | progress
        nativeTransport: true, // utiliser l'API native de streaming Slack quand mode=partial
      },
      mediaMaxMb: 20,
      execApprovals: {
        enabled: "auto", // true | false | "auto"
        approvers: ["U123"],
        agentFilter: ["default"],
        sessionFilter: ["slack:"],
        target: "dm", // dm | channel | both
      },
    },
  },
}

• Mode socket requiert botToken et appToken (SLACK_BOT_TOKEN + SLACK_APP_TOKEN comme repli env du compte par défaut).
• Mode HTTP requiert botToken plus signingSecret (à la racine ou par compte).
• botToken, appToken, signingSecret et userToken acceptent des chaînes en clair ou des objets SecretRef.
• Les instantanés de compte Slack exposent des champs source/statut par identifiant tels que botTokenSource, botTokenStatus, appTokenStatus et, en mode HTTP, signingSecretStatus. configured_unavailable signifie que le compte est configuré via SecretRef mais que le chemin actuel de commande/runtime n’a pas pu résoudre la valeur du secret.
• configWrites: false bloque les écritures de configuration initiées par Slack.
• channels.slack.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• channels.slack.streaming.mode est la clé canonique du mode de streaming Slack. channels.slack.streaming.nativeTransport contrôle le transport de streaming natif Slack. Les anciennes valeurs streamMode, booléennes streaming et nativeStreaming sont migrées automatiquement.
• Utilisez user:<id> (DM) ou channel:<id> pour les cibles de livraison.

• Le streaming natif Slack ainsi que le statut de fil Slack de type assistant « is typing… » requièrent une cible de fil de réponse. Les DM de niveau supérieur restent hors fil par défaut, ils utilisent donc typingReaction ou la livraison normale au lieu de l’aperçu de style fil.
• typingReaction ajoute une réaction temporaire au message Slack entrant pendant l’exécution d’une réponse, puis la supprime une fois terminée. Utilisez un shortcode emoji Slack tel que "hourglass_flowing_sand".
• channels.slack.execApprovals : livraison native Slack des approbations exec et autorisation des approbateurs. Même schéma que Discord : enabled (true/false/"auto"), approvers (ID utilisateur Slack), agentFilter, sessionFilter et target ("dm", "channel" ou "both").

​

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, // activation explicite
        nativeSkills: true,
        callbackPath: "/api/channels/mattermost/command",
        // URL explicite facultative pour les déploiements derrière proxy inverse/publics
        callbackUrl: "https://gateway.example.com/api/channels/mattermost/command",
      },
      textChunkLimit: 4000,
      chunkMode: "length",
    },
  },
}

• commands.callbackPath doit être un chemin (par exemple /api/channels/mattermost/command), pas une URL complète.
• commands.callbackUrl doit se résoudre vers le point de terminaison Gateway OpenClaw et être joignable depuis le serveur Mattermost.
• Les callbacks slash natifs sont authentifiés avec les jetons par commande renvoyés par Mattermost lors de l’enregistrement des slash commands. Si l’enregistrement échoue ou si aucune commande n’est activée, OpenClaw rejette les callbacks avec Unauthorized: invalid command token.
• Pour les hôtes de callback privés/tailnet/internes, Mattermost peut exiger que ServiceSettings.AllowedUntrustedInternalConnections inclue l’hôte/domaine de callback. Utilisez des valeurs d’hôte/domaine, pas des URL complètes.
• channels.mattermost.configWrites : autoriser ou interdire les écritures de configuration initiées par Mattermost.
• channels.mattermost.requireMention : exiger une @mention avant de répondre dans les canaux.
• channels.mattermost.groups.<channelId>.requireMention : remplacement de contrôle par mention par canal ("*" pour la valeur par défaut).
• channels.mattermost.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.

​

Signal

{
  channels: {
    signal: {
      enabled: true,
      account: "+15555550123", // liaison de compte facultative
      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 : épingler le démarrage du canal sur une identité de compte Signal spécifique.
• channels.signal.configWrites : autoriser ou interdire les écritures de configuration initiées par Signal.
• channels.signal.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.

​

BlueBubbles

{
  channels: {
    bluebubbles: {
      enabled: true,
      dmPolicy: "pairing",
      // serverUrl, password, webhookPath, contrôles de groupe et actions avancées :
      // voir /channels/bluebubbles
    },
  },
}

• Chemins de clé principaux couverts ici : channels.bluebubbles, channels.bluebubbles.dmPolicy.
• channels.bluebubbles.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• Les entrées bindings[] de niveau supérieur avec type: "acp" peuvent lier des conversations BlueBubbles à des sessions ACP persistantes. Utilisez un handle BlueBubbles ou une chaîne cible (chat_id:*, chat_guid:*, chat_identifier:*) dans match.peer.id. Sémantique partagée des champs : Agents ACP.
• La configuration complète du canal BlueBubbles est documentée dans BlueBubbles.

​

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",
      region: "US",
    },
  },
}

• channels.imessage.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• Nécessite un accès complet au disque pour la base de données Messages.
• Préférez les cibles chat_id:<id>. Utilisez imsg chats --limit 20 pour lister les discussions.
• cliPath peut pointer vers un wrapper SSH ; définissez remoteHost (host ou user@host) pour la récupération SCP des pièces jointes.
• attachmentRoots et remoteAttachmentRoots limitent les chemins des pièces jointes entrantes (par défaut : /Users/*/Library/Messages/Attachments).
• SCP utilise une vérification stricte de la clé d’hôte ; assurez-vous donc que la clé de l’hôte relais existe déjà dans ~/.ssh/known_hosts.
• channels.imessage.configWrites : autoriser ou interdire les écritures de configuration initiées par iMessage.
• Les entrées bindings[] de niveau supérieur avec type: "acp" peuvent lier des conversations iMessage à des sessions ACP persistantes. Utilisez un handle normalisé ou une cible de discussion explicite (chat_id:*, chat_guid:*, chat_identifier:*) dans match.peer.id. Sémantique partagée des champs : Agents ACP.

#!/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",
        },
      },
    },
  },
}

• L’authentification par jeton utilise accessToken ; l’authentification par mot de passe utilise userId + password.
• channels.matrix.proxy route le trafic HTTP Matrix via un proxy HTTP(S) explicite. Les comptes nommés peuvent le remplacer avec channels.matrix.accounts.<id>.proxy.
• channels.matrix.network.dangerouslyAllowPrivateNetwork autorise les homeservers privés/internes. proxy et cette activation réseau sont des contrôles indépendants.
• channels.matrix.defaultAccount sélectionne le compte préféré dans les configurations multi-comptes.
• channels.matrix.autoJoin vaut par défaut off, donc les salons invités et les nouvelles invitations de type DM sont ignorés jusqu’à ce que vous définissiez autoJoin: "allowlist" avec autoJoinAllowlist ou autoJoin: "always".
• channels.matrix.execApprovals : livraison native Matrix des approbations exec et autorisation des approbateurs.
  • enabled : true, false ou "auto" (par défaut). En mode auto, les approbations exec s’activent lorsque les approbateurs peuvent être résolus depuis approvers ou commands.ownerAllowFrom.
  • approvers : ID utilisateur Matrix (par ex. @owner:example.org) autorisés à approuver les demandes exec.
  • agentFilter : liste d’autorisation facultative des ID d’agent. Omettez pour transférer les approbations pour tous les agents.
  • sessionFilter : motifs facultatifs de clé de session (sous-chaîne ou regex).
  • target : où envoyer les invites d’approbation. "dm" (par défaut), "channel" (salon d’origine) ou "both".
  • Remplacements par compte : channels.matrix.accounts.<id>.execApprovals.
• channels.matrix.dm.sessionScope contrôle la manière dont les DM Matrix sont regroupés en sessions : per-user (par défaut) partage par pair routé, tandis que per-room isole chaque salon DM.
• Les sondes de statut Matrix et les recherches live dans l’annuaire utilisent la même politique de proxy que le trafic runtime.
• La configuration complète de Matrix, les règles de ciblage et les exemples de configuration sont documentés dans Matrix.

​

Microsoft Teams

{
  channels: {
    msteams: {
      enabled: true,
      configWrites: true,
      // appId, appPassword, tenantId, webhook, politiques équipe/canal :
      // voir /channels/msteams
    },
  },
}

• Chemins de clé principaux couverts ici : channels.msteams, channels.msteams.configWrites.
• La configuration complète de Teams (identifiants, webhook, politique DM/groupe, remplacements par équipe/canal) est documentée dans Microsoft Teams.

​

IRC

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

• Chemins de clé principaux couverts ici : channels.irc, channels.irc.dmPolicy, channels.irc.configWrites, channels.irc.nickserv.*.
• channels.irc.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un ID de compte configuré.
• La configuration complète du canal IRC (hôte/port/TLS/canaux/listes d’autorisation/contrôle par mention) est documentée dans IRC.

​

Multi-compte (tous les canaux)

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

• default est utilisé lorsque accountId est omis (CLI + routage).
• Les jetons d’environnement s’appliquent uniquement au compte default.
• Les paramètres de canal de base s’appliquent à tous les comptes sauf remplacement par compte.
• Utilisez bindings[].match.accountId pour router chaque compte vers un agent différent.
• Si vous ajoutez un compte non par défaut via openclaw channels add (ou l’onboarding de canal) alors que vous êtes encore sur une configuration de canal mono-compte au niveau supérieur, OpenClaw promeut d’abord les valeurs mono-compte de niveau supérieur à portée de compte dans la map de comptes du canal afin que le compte d’origine continue à fonctionner. La plupart des canaux les déplacent vers channels.<channel>.accounts.default ; Matrix peut à la place préserver une cible nommée/par défaut existante correspondante.
• Les liaisons existantes uniquement au niveau canal (sans accountId) continuent de correspondre au compte par défaut ; les liaisons à portée de compte restent facultatives.
• openclaw doctor --fix répare également les formes mixtes en déplaçant les valeurs mono-compte de niveau supérieur à portée de compte vers le compte promu choisi pour ce canal. La plupart des canaux utilisent accounts.default ; Matrix peut à la place préserver une cible nommée/par défaut existante correspondante.

​

Autres canaux de plugin

​

Contrôle par mention dans les discussions de groupe

• Mentions de métadonnées : @mentions natives de la plateforme. Ignorées en mode discussion avec soi-même sur WhatsApp.
• Motifs texte : motifs regex sûrs dans agents.list[].groupChat.mentionPatterns. Les motifs invalides et les répétitions imbriquées non sûres sont ignorés.
• Le contrôle par mention n’est appliqué que lorsque la détection est possible (mentions natives ou au moins un motif).

{
  messages: {
    groupChat: { historyLimit: 50 },
  },
  agents: {
    list: [{ id: "main", groupChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
  },
}

​

Limites d’historique DM

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

​

Mode discussion avec soi-même

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

​

Commandes (gestion des commandes de chat)

{
  commands: {
    native: "auto", // enregistrer les commandes natives lorsqu'elles sont prises en charge
    nativeSkills: "auto", // enregistrer les commandes natives de Skills lorsqu'elles sont prises en charge
    text: true, // analyser les /commandes dans les messages de chat
    bash: false, // autoriser ! (alias : /bash)
    bashForegroundMs: 2000,
    config: false, // autoriser /config
    mcp: false, // autoriser /mcp
    plugins: false, // autoriser /plugins
    debug: false, // autoriser /debug
    restart: true, // autoriser /restart + outil gateway restart
    ownerAllowFrom: ["discord:123456789012345678"],
    ownerDisplay: "raw", // raw | hash
    ownerDisplaySecret: "${OWNER_ID_HASH_SECRET}",
    allowFrom: {
      "*": ["user1"],
      discord: ["user:123"],
    },
    useAccessGroups: true,
  },
}

​

Associé

• Référence de configuration — clés de niveau supérieur
• Configuration — agents
• Vue d’ensemble des canaux