Configuration — canaux

​

Canaux

​

Accès aux DM et aux groupes

​

Remplacements de modèle par canal

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

​

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 du 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, inclut tout le contexte cité/fil/historique), allowlist (inclut 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 : inclut les statuts de canal sains dans la sortie Heartbeat.
• channels.defaults.heartbeat.showAlerts : inclut les statuts dégradés/erreur dans la sortie Heartbeat.
• channels.defaults.heartbeat.useIndicator : affiche une sortie Heartbeat compacte de type indicateur.

​

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

• Les entrées bindings[] de premier niveau avec type: "acp" configurent des liaisons ACP persistantes pour les DM et les groupes WhatsApp. Utilisez un numéro direct E.164 ou un JID de groupe WhatsApp dans match.peer.id. La sémantique des champs est partagée dans Agents ACP.

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

• Jeton de bot : channels.telegram.botToken ou channels.telegram.tokenFile (fichier normal uniquement ; les liens symboliques sont rejetés), avec TELEGRAM_BOT_TOKEN comme repli pour le compte par défaut.
• apiRoot est uniquement la racine de l’API Bot Telegram. Utilisez https://api.telegram.org ou votre racine auto-hébergée/proxy, pas https://api.telegram.org/bot<TOKEN> ; openclaw doctor --fix supprime un suffixe final /bot<TOKEN> accidentel.
• Le paramètre facultatif channels.telegram.defaultAccount remplace la sélection de compte par défaut lorsqu’il correspond à un ID de compte configuré.
• Dans les configurations multi-comptes (2+ ID de compte), définissez une valeur par défaut explicite (channels.telegram.defaultAccount ou channels.telegram.accounts.default) afin d’éviter un routage de repli ; openclaw doctor avertit lorsqu’elle est absente 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 premier niveau avec type: "acp" configurent des liaisons ACP persistantes pour les sujets de forum (utilisez le chatId:topic:topicId canonique dans match.peer.id). La sémantique des champs est partagée dans Agents ACP.
• Les aperçus de flux Telegram utilisent sendMessage + editMessageText (fonctionne dans les discussions directes et de groupe).
• Politique de nouvelle tentative : consultez 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,
      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,
      },
    },
  },
}

• Jeton : channels.discord.token, avec DISCORD_BOT_TOKEN comme solution de 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 nouvelle tentative et de stratégie du compte proviennent toujours du compte sélectionné dans l’instantané d’exécution actif.
• L’option facultative channels.discord.defaultAccount remplace la sélection du compte par défaut lorsqu’elle correspond à un ID de compte configuré.
• Utilisez user:<id> (DM) ou channel:<id> (salon de serveur) pour les cibles de livraison ; les ID numériques seuls sont rejetés.
• Les slugs de serveurs sont en minuscules, avec les espaces remplacés par - ; les clés de salon 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 bots qui mentionnent le bot (les propres messages restent filtrés).
• Les canaux qui prennent en charge les messages entrants rédigés par des bots peuvent utiliser la protection contre les boucles de bots partagée. Définissez channels.defaults.botLoopProtection pour les budgets de paires de référence, puis remplacez le canal ou le compte uniquement lorsqu’une surface nécessite des limites différentes.
• channels.discord.guilds.<id>.ignoreOtherMentions (et les remplacements au niveau des salons) ignore les messages qui mentionnent un autre utilisateur ou rôle, mais pas le bot (à l’exception de @everyone/@here).
• channels.discord.mentionAliases associe un texte @handle sortant stable à des ID d’utilisateurs Discord avant l’envoi, afin que les coéquipiers connus puissent être mentionnés de façon déterministe même lorsque le cache de répertoire transitoire est vide. Les remplacements par compte se trouvent sous channels.discord.accounts.<accountId>.mentionAliases.
• maxLinesPerMessage (17 par défaut) découpe les messages hauts même lorsqu’ils font moins de 2000 caractères.
• channels.discord.suppressEmbeds vaut true par défaut, afin que les URL sortantes ne se développent pas en aperçus de liens Discord sauf si cette option est désactivée. Les charges utiles embeds explicites sont toujours envoyées normalement ; les appels d’outils par message peuvent remplacer ce comportement avec suppressEmbeds.
• channels.discord.threadBindings contrôle le routage Discord lié aux fils :
  • enabled : remplacement Discord pour les fonctionnalités de session liées aux fils (/focus, /unfocus, /agents, /session idle, /session max-age, et livraison/routage liés)
  • idleHours : remplacement Discord pour la défocalisation automatique après inactivité, en heures (0 désactive)
  • maxAgeHours : remplacement Discord pour l’âge maximal strict, en heures (0 désactive)
  • spawnSessions : interrupteur pour sessions_spawn({ thread: true }) et la création/liaison automatique de fils pour ACP thread-spawn (par défaut : true)
  • defaultSpawnContext : contexte de sous-agent natif pour les lancements liés à un fil ("fork" par défaut)
• Les entrées bindings[] de premier niveau 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 des conteneurs de composants Discord v2.
• channels.discord.agentComponents.ttlMs contrôle la durée pendant laquelle les callbacks de composants Discord envoyés restent enregistrés. La valeur par défaut est 1800000 (30 minutes), le maximum est 86400000 (24 heures), et les remplacements par compte se trouvent sous channels.discord.accounts.<accountId>.agentComponents.ttlMs. Des valeurs plus longues gardent les anciens boutons/sélecteurs/formulaires utilisables plus longtemps ; préférez donc le TTL le plus court adapté au flux de travail.
• channels.discord.voice active les conversations dans les canaux vocaux Discord ainsi que les remplacements facultatifs auto-join + LLM + TTS. Les configurations Discord uniquement textuelles laissent la voix désactivée par défaut ; définissez channels.discord.voice.enabled=true pour l’activer.
• channels.discord.voice.model remplace facultativement le modèle LLM utilisé pour les réponses dans les canaux vocaux Discord.
• channels.discord.voice.daveEncryption et channels.discord.voice.decryptionFailureTolerance sont transmis aux options DAVE de @discordjs/voice (true et 24 par défaut).
• channels.discord.voice.connectTimeoutMs contrôle l’attente initiale Ready de @discordjs/voice pour /vc join et les tentatives d’auto-join (30000 par défaut).
• channels.discord.voice.reconnectGraceMs contrôle le délai dont dispose une session vocale déconnectée pour entrer en signalisation de reconnexion avant qu’OpenClaw ne la détruise (15000 par défaut).
• La lecture vocale Discord n’est pas interrompue par l’événement de début de parole d’un autre utilisateur. Pour éviter les boucles de retour audio, OpenClaw ignore les nouvelles captures vocales pendant la lecture TTS.
• OpenClaw tente également de récupérer la réception vocale en quittant puis rejoignant une session vocale après des échecs de déchiffrement répétés.
• channels.discord.streaming est la clé canonique du mode de flux. Discord utilise par défaut streaming.mode: "progress" afin que la progression des outils/du travail apparaisse dans un seul message d’aperçu modifié ; définissez streaming.mode: "off" pour le désactiver. Les anciennes valeurs streamMode et les valeurs booléennes streaming restent des alias d’exécution ; exécutez openclaw doctor --fix pour réécrire la configuration persistée.
• channels.discord.autoPresence associe la disponibilité d’exécution à la présence du bot (healthy => online, degraded => idle, exhausted => dnd) et permet des remplacements facultatifs du texte de statut.
• channels.discord.dangerouslyAllowNameMatching réactive la correspondance mutable par nom/tag (mode de compatibilité d’urgence).
• channels.discord.execApprovals : livraison d’approbations exec native Discord 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 d’utilisateurs Discord autorisés à approuver les demandes exec. Se rabat sur commands.ownerAllowFrom en cas d’omission.
  • agentFilter : liste d’autorisation facultative d’ID d’agents. Omettez-la pour transférer les approbations de tous les agents.
  • sessionFilter : motifs facultatifs de clés de session (sous-chaîne ou expression régulière).
  • target : où envoyer les demandes d’approbation. "dm" (par défaut) les envoie aux DM des approbateurs, "channel" les envoie au 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 de compte de service : en ligne (serviceAccount) ou basé sur un fichier (serviceAccountFile).
• SecretRef de compte de service est également pris en charge (serviceAccountRef).
• Solutions de repli d’environnement : 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é d’urgence).

​

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

• Le mode socket nécessite à la fois botToken et appToken (SLACK_BOT_TOKEN + SLACK_APP_TOKEN pour le repli env du compte par défaut).
• Le mode HTTP nécessite botToken plus signingSecret (à la racine ou par compte).
• socketMode transmet le réglage du transport Socket Mode du SDK Slack à l’API publique du récepteur Bolt. Utilisez-le uniquement lorsque vous investiguez des délais d’expiration ping/pong ou un comportement de websocket obsolète. clientPingTimeout vaut 15000 par défaut ; serverPingTimeout et pingPongLoggingEnabled ne sont transmis que s’ils sont configurés.
• botToken, appToken, signingSecret et userToken acceptent des chaînes en texte brut ou des objets SecretRef.
• Les instantanés de compte Slack exposent des champs source/statut par identifiant, comme botTokenSource, botTokenStatus, appTokenStatus et, en mode HTTP, signingSecretStatus. configured_unavailable signifie que le compte est configuré via SecretRef mais que le chemin de commande/runtime actuel n’a pas pu résoudre la valeur du secret.
• configWrites: false bloque les écritures de configuration initiées par Slack.
• channels.slack.defaultAccount optionnel remplace la sélection du compte par défaut lorsqu’il correspond à un identifiant de compte configuré.
• channels.slack.streaming.mode est la clé canonique du mode de flux Slack. channels.slack.streaming.nativeTransport contrôle le transport de streaming natif de Slack. Les valeurs héritées streamMode, le booléen streaming et nativeStreaming restent des alias runtime ; exécutez openclaw doctor --fix pour réécrire la configuration persistée.
• unfurlLinks et unfurlMedia transmettent les booléens de déroulement des liens et médias chat.postMessage de Slack pour les réponses du bot. unfurlLinks vaut false par défaut afin que les liens sortants du bot ne se développent pas en ligne sauf activation ; unfurlMedia est omis sauf s’il est configuré. Définissez l’une ou l’autre valeur dans channels.slack.accounts.<accountId> pour remplacer la valeur de premier niveau pour un compte.
• Utilisez user:<id> (DM) ou channel:<id> pour les cibles de livraison.

• Le streaming natif Slack et le statut de fil de type assistant Slack « is typing… » nécessitent une cible de fil de réponse. Les DM de premier niveau restent hors fil par défaut, ils peuvent donc toujours diffuser via les aperçus Slack de publication brouillon puis édition au lieu d’afficher l’aperçu de flux/statut natif de style fil.
• typingReaction ajoute une réaction temporaire au message Slack entrant pendant qu’une réponse est en cours, puis la supprime à la fin. Utilisez un shortcode d’emoji Slack comme "hourglass_flowing_sand".
• channels.slack.execApprovals : livraison client d’approbation native Slack et autorisation des approbateurs exec. Même schéma que Discord : enabled (true/false/"auto"), approvers (identifiants d’utilisateur Slack), agentFilter, sessionFilter et target ("dm", "channel" ou "both"). Les approbations Plugin peuvent utiliser ce chemin de client natif pour les requêtes d’origine Slack lorsque les approbateurs du Plugin Slack sont résolus ; la livraison d’approbation Plugin native Slack peut aussi être activée via approvals.plugin pour les sessions d’origine Slack ou les cibles Slack. Les approbations Plugin utilisent les approbateurs du Plugin Slack depuis allowFrom et le routage par défaut, pas les approbateurs exec.

​

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 doit être un chemin (par exemple /api/channels/mattermost/command), pas une URL complète.
• commands.callbackUrl doit résoudre vers le point de terminaison Gateway d’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 commandes slash. 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 nécessiter 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 refuser les écritures de configuration initiées par Mattermost.
• channels.mattermost.requireMention : exiger @mention avant de répondre dans les canaux.
• channels.mattermost.groups.<channelId>.requireMention : remplacement du filtrage par mention par canal ("*" pour la valeur par défaut).
• channels.mattermost.defaultAccount optionnel remplace la sélection du compte par défaut lorsqu’il correspond à un identifiant de compte configuré.

​

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 : épingler le démarrage du canal à une identité de compte Signal spécifique.
• channels.signal.configWrites : autoriser ou refuser les écritures de configuration initiées par Signal.
• channels.signal.defaultAccount optionnel remplace la sélection du compte par défaut lorsqu’il correspond à un identifiant de compte configuré.

​

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

• channels.imessage.defaultAccount optionnel remplace la sélection du compte par défaut lorsqu’il correspond à un identifiant de compte configuré.
• Nécessite l’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 chats.
• cliPath peut pointer vers un wrapper SSH ; définissez remoteHost (host ou user@host) pour la récupération des pièces jointes via SCP.
• attachmentRoots et remoteAttachmentRoots restreignent les chemins de pièces jointes entrantes (par défaut : /Users/*/Library/Messages/Attachments).
• SCP utilise une vérification stricte des clés 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 refuser les écritures de configuration initiées par iMessage.
• channels.imessage.sendTransport : transport d’envoi RPC imsg préféré pour les réponses sortantes normales. auto (par défaut) utilise le pont IMCore pour les chats existants lorsqu’il est en cours d’exécution, puis se replie sur AppleScript ; bridge nécessite une livraison par API privée ; applescript force le chemin d’automatisation public de Messages.
• channels.imessage.actions.* : activer les actions d’API privée qui sont aussi contrôlées par imsg status / openclaw channels status --probe.
• channels.imessage.includeAttachments est désactivé par défaut ; définissez-le sur true avant d’attendre des médias entrants dans les tours d’agent.
• La récupération entrante après un redémarrage du pont/Gateway est automatique (déduplication GUID plus barrière d’âge pour backlog obsolète). Les configurations existantes channels.imessage.catchup.enabled: true sont toujours honorées comme profil de compatibilité déprécié.
• channels.imessage.groups : registre de groupes et paramètres par groupe. Avec groupPolicy: "allowlist", configurez soit des clés chat_id explicites, soit une entrée générique "*" afin que les messages de groupe puissent franchir le contrôle du registre.
• Les entrées de premier niveau bindings[] avec type: "acp" peuvent lier des conversations iMessage à des sessions ACP persistantes. Utilisez un identifiant normalisé ou une cible de chat explicite (chat_id:*, chat_guid:*, chat_identifier:*) dans match.peer.id. Sémantique des champs partagés : 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 achemine 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 option réseau explicite sont des contrôles indépendants.
• channels.matrix.defaultAccount sélectionne le compte préféré dans les configurations multicomptes.
• channels.matrix.autoJoin vaut off par défaut, donc les salons sur invitation 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 des approbations d’exécution natives Matrix et autorisation des approbateurs.
  • enabled : true, false ou "auto" (par défaut). En mode auto, les approbations d’exécution s’activent lorsque les approbateurs peuvent être résolus depuis approvers ou commands.ownerAllowFrom.
  • approvers : identifiants utilisateur Matrix (par ex. @owner:example.org) autorisés à approuver les demandes d’exécution.
  • agentFilter : liste d’autorisation optionnelle d’identifiants d’agent. Omettez-la pour transmettre les approbations à tous les agents.
  • sessionFilter : motifs optionnels de clés de session (sous-chaîne ou regex).
  • target : destination des 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 acheminé, tandis que per-room isole chaque salon DM.
• Les sondes d’état Matrix et les recherches d’annuaire en direct utilisent la même politique de proxy que le trafic d’exécution.
• La configuration Matrix complète, 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, team/channel policies:
      // see /channels/msteams
    },
  },
}

• Chemins de clés principaux couverts ici : channels.msteams, channels.msteams.configWrites.
• La configuration Teams complète (identifiants, webhook, politique de DM/groupe, remplacements par équipe/par 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és principaux couverts ici : channels.irc, channels.irc.dmPolicy, channels.irc.configWrites, channels.irc.nickserv.*.
• channels.irc.defaultAccount optionnel remplace la sélection de compte par défaut lorsqu’il correspond à un identifiant de compte configuré.
• La configuration complète du canal IRC (hôte/port/TLS/canaux/listes d’autorisation/filtrage par mention) est documentée dans IRC.

​

Multicomptes (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 ne s’appliquent qu’au compte default.
• Les paramètres de canal de base s’appliquent à tous les comptes sauf remplacement par compte.
• Utilisez bindings[].match.accountId pour acheminer chaque compte vers un agent différent.
• Si vous ajoutez un compte non par défaut via openclaw channels add (ou l’intégration du canal) tout en restant sur une configuration de canal de premier niveau à compte unique, OpenClaw promeut d’abord les valeurs de premier niveau à compte unique propres au compte dans la carte des comptes du canal afin que le compte d’origine continue de fonctionner. La plupart des canaux les déplacent vers channels.<channel>.accounts.default ; Matrix peut à la place conserver une cible nommée/par défaut correspondante existante.
• Les liaisons existantes limitées au canal (sans accountId) continuent de correspondre au compte par défaut ; les liaisons propres au compte restent optionnelles.
• openclaw doctor --fix répare aussi les formes mixtes en déplaçant les valeurs de premier niveau à compte unique propres au compte vers le compte promu choisi pour ce canal. La plupart des canaux utilisent accounts.default ; Matrix peut à la place conserver une cible nommée/par défaut correspondante existante.

​

Autres canaux de Plugin

​

Filtrage des mentions dans les discussions de groupe

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

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

​

Limites d’historique des DM

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

​

Mode self-chat

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

​

Commandes (gestion des commandes de chat)

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

​

Associé

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