Configuration — canaux

Documentation Index

Fetch the complete documentation index at: https://docs2.openclaw.ai/llms.txt

Use this file to discover all available pages before exploring further.

​

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-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 du fournisseur n’est pas défini.
• channels.defaults.contextVisibility : mode de visibilité par défaut du contexte supplémentaire pour tous les canaux. Valeurs : all (par défaut, inclut tout le contexte cité/fil/historique), allowlist (inclut uniquement le contexte provenant d’expéditeurs autorisés), allowlist_quote (identique à allowlist, mais conserve le contexte de citation/réponse explicite). Remplacement par canal : channels.<channel>.contextVisibility.
• channels.defaults.heartbeat.showOk : inclut les statuts de canaux sains dans la sortie de Heartbeat.
• channels.defaults.heartbeat.showAlerts : inclut les statuts dégradés/en erreur dans la sortie de 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"],
    },
  },
}

{
  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; opt in explicitly to avoid preview-edit rate limits)
      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 du bot : channels.telegram.botToken ou channels.telegram.tokenFile (fichier standard uniquement ; liens symboliques rejetés), avec TELEGRAM_BOT_TOKEN comme repli pour le compte par défaut.
• apiRoot est uniquement la racine de l’API Telegram Bot. 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.
• L’option channels.telegram.defaultAccount remplace la sélection du compte par défaut lorsqu’elle correspond à un ID de compte configuré.
• Dans les configurations multi-comptes (2 ID de compte ou plus), définissez explicitement une valeur par défaut (channels.telegram.defaultAccount ou channels.telegram.accounts.default) afin d’éviter le routage de repli ; openclaw doctor avertit lorsque celle-ci est manquante ou invalide.
• configWrites: false bloque les écritures de configuration initiées par Telegram (migrations d’ID de supergroupe, /config set|unset).
• Les entrées de premier niveau bindings[] avec type: "acp" configurent des liaisons ACP persistantes pour les sujets 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 flux Telegram utilisent sendMessage + editMessageText (fonctionne dans les discussions directes et de groupe).
• Politique de réessai : consultez Politique de réessai.

​

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: {
        mode: "progress", // off | partial | block | progress (Discord default: progress)
        progress: {
          label: "auto",
          maxLines: 8,
          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/de politique du compte proviennent toujours du compte sélectionné dans l’instantané d’exécution actif.
• channels.discord.defaultAccount facultatif remplace la sélection du compte par défaut lorsqu’il correspond à un identifiant de compte configuré.
• Utilisez user:<id> (DM) ou channel:<id> (canal de guilde) pour les cibles de livraison ; les identifiants numériques nus sont rejetés.
• Les slugs de guilde sont en minuscules, avec les espaces remplacés par - ; les clés de canal utilisent le nom slugifié (sans #). Préférez les identifiants de guilde.
• 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).
• channels.discord.guilds.<id>.ignoreOtherMentions (et les remplacements par canal) supprime les messages qui mentionnent un autre utilisateur ou rôle mais pas le bot (hors @everyone/@here).
• channels.discord.mentionAliases associe le texte sortant stable @handle aux identifiants 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) fractionne les messages longs même sous 2 000 caractères.
• 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 suppression automatique du focus après inactivité, en heures (0 désactive)
  • maxAgeHours : remplacement Discord pour l’âge maximal strict, en heures (0 désactive)
  • spawnSessions : commutateur pour sessions_spawn({ thread: true }) et la création/liaison automatique de fils lors du démarrage de fils ACP (par défaut : true)
  • defaultSpawnContext : contexte natif de sous-agent pour les démarrages liés aux fils ("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’identifiant 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 Discord components v2.
• channels.discord.voice active les conversations dans les canaux vocaux Discord, avec auto-join facultatif et remplacements LLM + TTS. Les configurations Discord texte uniquement 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 Ready initiale 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 pendant lequel une session vocale déconnectée peut 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 rétroaction, OpenClaw ignore les nouvelles captures vocales pendant la lecture TTS.
• OpenClaw tente également une récupération de réception vocale en quittant/rejoignant une session vocale après des échecs de déchiffrement répétés.
• channels.discord.streaming est la clé canonique du mode 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 anciens champs 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 autorise 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 d’exécution native Discord 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 d’utilisateurs Discord autorisés à approuver les demandes d’exécution. Se replie sur commands.ownerAllowFrom lorsqu’il est omis.
  • agentFilter : liste d’autorisation facultative d’identifiants 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 invites d’approbation. "dm" (par défaut) envoie aux DM des approbateurs, "channel" envoie au canal d’origine, "both" 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 du délai.

​

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).
• Le 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 des principaux 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 la solution de repli d’environnement 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 lors de l’analyse des délais ping/pong ou d’un comportement websocket obsolète.
• botToken, appToken, signingSecret et userToken acceptent des chaînes en texte clair 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/d’exécution 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 facultatif 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 flux Slack. channels.slack.streaming.nativeTransport contrôle le transport de streaming natif de Slack. Les anciens champs streamMode, les valeurs booléennes streaming et nativeStreaming restent des alias d’exécution ; exécutez openclaw doctor --fix pour réécrire la configuration persistée.
• unfurlLinks et unfurlMedia transmettent les booléens de dépliage de liens et de médias de chat.postMessage de Slack pour les réponses de bot. Omettez-les pour conserver le comportement par défaut de Slack ; définissez-les dans channels.slack.accounts.<accountId> pour remplacer la valeur par défaut de premier niveau pour un compte.
• Utilisez user:<id> (DM) ou channel:<id> pour les cibles de livraison.

• Le streaming natif Slack avec le statut de fil « is typing… » de type assistant Slack nécessite une cible de fil de réponse. Les DM de premier niveau restent hors fil par défaut, afin qu’ils puissent toujours diffuser via des aperçus de brouillon Slack publiés puis modifiés 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 l’exécution d’une réponse, puis la supprime à la fin. Utilisez un shortcode d’emoji Slack tel que "hourglass_flowing_sand".
• channels.slack.execApprovals : livraison d’approbations d’exécution native Slack et autorisation des approbateurs. Même schéma que Discord : enabled (true/false/"auto"), approvers (identifiants d’utilisateurs 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, // 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), et non une URL complète.
• commands.callbackUrl doit résoudre vers le point de terminaison du Gateway OpenClaw et être accessible depuis le serveur Mattermost.
• Les rappels slash natifs sont authentifiés avec les jetons propres à chaque 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 rappels avec Unauthorized: invalid command token.
• Pour les hôtes de rappel privés/tailnet/internes, Mattermost peut exiger que ServiceSettings.AllowedUntrustedInternalConnections inclue l’hôte ou le domaine de rappel. Utilisez des valeurs d’hôte ou de domaine, et non 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 propre au canal ("*" par défaut).
• channels.mattermost.defaultAccount facultatif 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 : associer 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 facultatif 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",
      region: "US",
      actions: {
        reactions: true,
        edit: true,
        unsend: true,
        reply: true,
        sendWithEffect: true,
        sendAttachment: true,
      },
      catchup: {
        enabled: false,
      },
    },
  },
}

• channels.imessage.defaultAccount facultatif 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 discussions.
• cliPath peut pointer vers un wrapper SSH ; définissez remoteHost (host ou user@host) pour la récupération des pièces jointes par SCP.
• attachmentRoots et remoteAttachmentRoots limitent les chemins des 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.actions.* : activer les actions d’API privées qui sont également 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 de l’agent.
• channels.imessage.catchup.enabled : activer la relecture des messages entrants arrivés pendant que le Gateway était arrêté.
• 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 bindings[] de premier niveau avec type: "acp" peuvent lier des conversations iMessage à des sessions ACP persistantes. Utilisez un identifiant normalisé ou une cible de discussion 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 activation réseau 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 ; les salons sur invitation et les nouvelles invitations de type DM sont donc ignorés jusqu’à ce que vous définissiez autoJoin: "allowlist" avec autoJoinAllowlist ou autoJoin: "always".
• channels.matrix.execApprovals : livraison d’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 exemple @owner:example.org) autorisés à approuver les demandes d’exécution.
  • agentFilter : liste d’autorisation facultative d’identifiants d’agent. Omettez-la pour transférer les approbations pour tous les agents.
  • sessionFilter : motifs facultatifs de clés de session (sous-chaîne ou expression régulière).
  • 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 routé, 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 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, team/channel policies:
      // see /channels/msteams
    },
  },
}

• Chemins de clés principaux couverts ici : channels.msteams, channels.msteams.configWrites.
• La configuration complète de Teams (identifiants, webhook, politique 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 facultatif remplace la sélection du 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 s’appliquent uniquement au compte par défaut.
• 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 autre que celui par défaut via openclaw channels add (ou l’onboarding du canal) alors que vous êtes encore sur une configuration de canal de premier niveau à compte unique, OpenClaw promeut d’abord les valeurs de compte unique de premier niveau propres au compte dans la carte de comptes du canal afin que le compte d’origine continue de fonctionner. La plupart des canaux les déplacent dans channels.<channel>.accounts.default ; Matrix peut préserver à la place 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 à un compte restent facultatives.
• openclaw doctor --fix répare également les formes mixtes en déplaçant les valeurs de compte unique de premier niveau propres au compte vers le compte promu choisi pour ce canal. La plupart des canaux utilisent accounts.default ; Matrix peut préserver à la place une cible nommée/par défaut correspondante existante.

​

Autres canaux Plugin

​

Filtrage par mention dans les discussions de groupe

• Mentions de métadonnées : @-mentions natives de la plateforme. Ignorées en mode auto-conversation WhatsApp.
• Motifs textuels : 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 filtrage par mention n’est appliqué que lorsque la détection est possible (mentions natives ou au moins un motif).

{
  messages: {
    visibleReplies: "automatic", // global default for direct/source chats; Codex harness defaults unset direct chats to message_tool
    groupChat: {
      historyLimit: 50,
      visibleReplies: "message_tool", // default; use "automatic" for legacy final replies
    },
  },
  agents: {
    list: [{ id: "main", groupChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
  },
}

​

Limites d’historique des MP

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

​

Mode auto-conversation

{
  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