Configuration — outils et fournisseurs personnalisés

tools.* Clés de configuration et configuration d’un fournisseur personnalisé / d’URL de base. Pour les agents, les canaux et les autres clés de configuration de premier niveau, consultez la référence de configuration.

Outils

Profils d’outils

tools.profile définit une liste d’autorisation de base avant tools.allow/tools.deny :

L’intégration locale attribue par défaut aux nouvelles configurations locales tools.profile: "coding" lorsque cette valeur n’est pas définie (les profils explicites existants sont conservés).

Profil	Inclut
`minimal`	`session_status` uniquement
`coding`	`group:fs`, `group:runtime`, `group:web`, `group:sessions`, `group:memory`, `cron`, `image`, `image_generate`, `video_generate`
`messaging`	`group:messaging`, `sessions_list`, `sessions_history`, `sessions_send`, `session_status`
`full`	Aucune restriction (identique à une valeur non définie)

Groupes d’outils

Groupe	Outils
`group:runtime`	`exec`, `process`, `code_execution` (`bash` est accepté comme alias pour `exec`)
`group:fs`	`read`, `write`, `edit`, `apply_patch`
`group:sessions`	`sessions_list`, `sessions_history`, `sessions_send`, `sessions_spawn`, `sessions_yield`, `subagents`, `session_status`
`group:memory`	`memory_search`, `memory_get`
`group:web`	`web_search`, `x_search`, `web_fetch`
`group:ui`	`browser`, `canvas`
`group:automation`	`heartbeat_respond`, `cron`, `gateway`
`group:messaging`	`message`
`group:nodes`	`nodes`
`group:agents`	`agents_list`, `update_plan`
`group:media`	`image`, `image_generate`, `music_generate`, `video_generate`, `tts`
`group:openclaw`	Tous les outils intégrés (exclut les plugins fournisseurs)

`tools.allow` / `tools.deny`

Politique globale d’autorisation/refus des outils (le refus l’emporte). Insensible à la casse, prend en charge les caractères génériques *. Appliquée même lorsque le sandbox Docker est désactivé.

{
  tools: { deny: ["browser", "canvas"] },
}

write et apply_patch sont des identifiants d’outils distincts. allow: ["write"] active aussi apply_patch pour les modèles compatibles, mais deny: ["write"] ne refuse pas apply_patch. Pour bloquer toute mutation de fichier, refusez group:fs ou listez explicitement chaque outil de mutation :

{
  tools: { deny: ["write", "edit", "apply_patch"] },
}

`tools.byProvider`

Restreint davantage les outils pour des fournisseurs ou modèles spécifiques. Ordre : profil de base → profil du fournisseur → autorisation/refus.

{
  tools: {
    profile: "coding",
    byProvider: {
      "google-antigravity": { profile: "minimal" },
      "openai/gpt-5.4": { allow: ["group:fs", "sessions_list"] },
    },
  },
}

`tools.toolsBySender`

Restreint les outils pour une identité de demandeur spécifique. Il s’agit d’une défense en profondeur en plus du contrôle d’accès au canal ; les valeurs d’expéditeur doivent provenir de l’adaptateur de canal, et non du texte du message.

{
  tools: {
    toolsBySender: {
      "channel:discord:1234567890123": { alsoAllow: ["group:fs"] },
      "id:guest-user-id": { deny: ["group:runtime", "group:fs"] },
      "*": { deny: ["exec", "process", "write", "edit", "apply_patch"] },
    },
  },
}

Les clés utilisent des préfixes explicites : channel:<channelId>:<senderId>, id:<senderId>, e164:<phone>, username:<handle>, name:<displayName>, ou "*". Les identifiants de canaux sont les identifiants canoniques OpenClaw ; les alias comme teams sont normalisés en msteams. Les anciennes clés sans préfixe sont acceptées uniquement comme id:. L’ordre de correspondance est channel+id, id, e164, username, name, puis le caractère générique. agents.list[].tools.toolsBySender par agent remplace la correspondance globale de l’expéditeur lorsqu’il correspond, même avec une politique vide {}.

`tools.elevated`

Contrôle l’accès exec élevé hors du sandbox :

{
  tools: {
    elevated: {
      enabled: true,
      allowFrom: {
        whatsapp: ["+15555550123"],
        discord: ["1234567890123", "987654321098765432"],
      },
    },
  },
}

Le remplacement par agent (agents.list[].tools.elevated) ne peut que restreindre davantage.
/elevated on|off|ask|full stocke l’état par session ; les directives en ligne s’appliquent à un seul message.
exec élevé contourne le sandboxing et utilise le chemin d’échappement configuré (gateway par défaut, ou node lorsque la cible exec est node).

`tools.exec`

{
  tools: {
    exec: {
      backgroundMs: 10000,
      timeoutSec: 1800,
      cleanupMs: 1800000,
      notifyOnExit: true,
      notifyOnExitEmptySuccess: false,
      commandHighlighting: false,
      applyPatch: {
        enabled: false,
        allowModels: ["gpt-5.5"],
      },
    },
  },
}

`tools.loopDetection`

Les vérifications de sécurité des boucles d’outils sont désactivées par défaut. Définissez enabled: true pour activer la détection. Les paramètres peuvent être définis globalement dans tools.loopDetection et remplacés par agent dans agents.list[].tools.loopDetection.

{
  tools: {
    loopDetection: {
      enabled: true,
      historySize: 30,
      warningThreshold: 10,
      criticalThreshold: 20,
      globalCircuitBreakerThreshold: 30,
      detectors: {
        genericRepeat: true,
        knownPollNoProgress: true,
        pingPong: true,
      },
    },
  },
}

historySize

number

Historique maximal des appels d’outils conservé pour l’analyse des boucles.

warningThreshold

number

Seuil de motif répété sans progression pour les avertissements.

criticalThreshold

number

Seuil de répétition plus élevé pour bloquer les boucles critiques.

globalCircuitBreakerThreshold

number

Seuil d’arrêt strict pour toute exécution sans progression.

detectors.genericRepeat

boolean

Avertir en cas d’appels répétés avec le même outil et les mêmes arguments.

detectors.knownPollNoProgress

boolean

Avertir/bloquer sur les outils d’interrogation connus (process.poll, command_status, etc.).

detectors.pingPong

boolean

Avertir/bloquer sur les motifs de paires alternées sans progression.

Si warningThreshold >= criticalThreshold ou criticalThreshold >= globalCircuitBreakerThreshold, la validation échoue.

`tools.web`

{
  tools: {
    web: {
      search: {
        enabled: true,
        apiKey: "brave_api_key", // or BRAVE_API_KEY env
        maxResults: 5,
        timeoutSeconds: 30,
        cacheTtlMinutes: 15,
      },
      fetch: {
        enabled: true,
        provider: "firecrawl", // optional; omit for auto-detect
        maxChars: 50000,
        maxCharsCap: 50000,
        maxResponseBytes: 2000000,
        timeoutSeconds: 30,
        cacheTtlMinutes: 15,
        maxRedirects: 3,
        readability: true,
        userAgent: "custom-ua",
      },
    },
  },
}

`tools.media`

Configure la compréhension des médias entrants (image/audio/vidéo) :

{
  tools: {
    media: {
      concurrency: 2,
      asyncCompletion: {
        directSend: false, // deprecated: completions stay agent-mediated
      },
      audio: {
        enabled: true,
        maxBytes: 20971520,
        scope: {
          default: "deny",
          rules: [{ action: "allow", match: { chatType: "direct" } }],
        },
        models: [
          { provider: "openai", model: "gpt-4o-mini-transcribe" },
          { type: "cli", command: "whisper", args: ["--model", "base", "{{MediaPath}}"] },
        ],
      },
      image: {
        enabled: true,
        timeoutSeconds: 180,
        models: [{ provider: "ollama", model: "gemma4:26b", timeoutSeconds: 300 }],
      },
      video: {
        enabled: true,
        maxBytes: 52428800,
        models: [{ provider: "google", model: "gemini-3-flash-preview" }],
      },
    },
  },
}

Media model entry fields

Entrée de fournisseur (type: "provider" ou omis) :

provider : identifiant du fournisseur d’API (openai, anthropic, google/gemini, groq, etc.)
model : remplacement de l’identifiant du modèle
profile / preferredProfile : sélection de profil auth-profiles.json

Entrée CLI (type: "cli") :

command : exécutable à lancer
args : arguments modélisés (prend en charge {{MediaPath}}, {{Prompt}}, {{MaxChars}}, etc. ; openclaw doctor --fix migre les espaces réservés obsolètes {input} vers {{MediaPath}})

Champs communs :

capabilities : liste facultative (image, audio, video). Valeurs par défaut : openai/anthropic/minimax → image, google → image+audio+vidéo, groq → audio.
prompt, maxChars, maxBytes, timeoutSeconds, language : remplacements par entrée.
tools.media.image.timeoutSeconds et les entrées timeoutSeconds du modèle d’image correspondant s’appliquent aussi lorsque l’agent appelle l’outil image explicite.
Les échecs basculent vers l’entrée suivante.

L’authentification du fournisseur suit l’ordre standard : auth-profiles.json → variables d’environnement → models.providers.*.apiKey.Champs de complétion asynchrone :

asyncCompletion.directSend : indicateur de compatibilité obsolète. Les tâches média asynchrones terminées restent médiées par la session demandeuse afin que l’agent reçoive le résultat, décide comment le communiquer à l’utilisateur et utilise l’outil de message lorsque la livraison à la source l’exige.

`tools.agentToAgent`

{
  tools: {
    agentToAgent: {
      enabled: false,
      allow: ["home", "work"],
    },
  },
}

`tools.sessions`

Contrôle les sessions qui peuvent être ciblées par les outils de session (sessions_list, sessions_history, sessions_send). Par défaut : tree (session actuelle + sessions qu’elle a lancées, comme les sous-agents).

{
  tools: {
    sessions: {
      // "self" | "tree" | "agent" | "all"
      visibility: "tree",
    },
  },
}

Visibility scopes

self : uniquement la clé de session actuelle.
tree : session actuelle + sessions lancées par la session actuelle (sous-agents).
agent : toute session appartenant à l’identifiant de l’agent actuel (peut inclure d’autres utilisateurs si vous exécutez des sessions par expéditeur sous le même identifiant d’agent).
all : toute session. Le ciblage inter-agents nécessite toujours tools.agentToAgent.
Contrainte de bac à sable : lorsque la session actuelle est exécutée en bac à sable et que agents.defaults.sandbox.sessionToolsVisibility="spawned", la visibilité est forcée à tree même si tools.sessions.visibility="all".

`tools.sessions_spawn`

Contrôle la prise en charge des pièces jointes intégrées pour sessions_spawn.

{
  tools: {
    sessions_spawn: {
      attachments: {
        enabled: false, // opt-in: set true to allow inline file attachments
        maxTotalBytes: 5242880, // 5 MB total across all files
        maxFiles: 50,
        maxFileBytes: 1048576, // 1 MB per file
        retainOnSessionKeep: false, // keep attachments when cleanup="keep"
      },
    },
  },
}

Notes sur les pièces jointes

Les pièces jointes ne sont prises en charge que pour runtime: "subagent". Le runtime ACP les rejette.
Les fichiers sont matérialisés dans l’espace de travail enfant sous .openclaw/attachments/<uuid>/ avec un .manifest.json.
Le contenu des pièces jointes est automatiquement expurgé de la persistance de la transcription.
Les entrées Base64 sont validées avec des contrôles stricts de l’alphabet et du remplissage, ainsi qu’une garde de taille avant décodage.
Les autorisations de fichiers sont 0700 pour les répertoires et 0600 pour les fichiers.
Le nettoyage suit la politique cleanup : delete supprime toujours les pièces jointes ; keep les conserve uniquement lorsque retainOnSessionKeep: true.

`tools.experimental`

Indicateurs expérimentaux des outils intégrés. Désactivés par défaut, sauf si une règle d’activation automatique stricte-agentique GPT-5 s’applique.

{
  tools: {
    experimental: {
      planTool: true, // enable experimental update_plan
    },
  },
}

planTool : active l’outil structuré update_plan pour le suivi des travaux non triviaux en plusieurs étapes.
Par défaut : false, sauf si agents.defaults.embeddedPi.executionContract (ou une surcharge par agent) est défini sur "strict-agentic" pour une exécution de la famille GPT-5 OpenAI ou OpenAI Codex. Définissez true pour forcer l’activation de l’outil hors de ce périmètre, ou false pour le maintenir désactivé même pour les exécutions GPT-5 strictes-agentiques.
Lorsqu’il est activé, l’invite système ajoute aussi des consignes d’utilisation afin que le modèle ne l’utilise que pour des travaux substantiels et conserve au plus une étape in_progress.

`agents.defaults.subagents`

{
  agents: {
    defaults: {
      subagents: {
        allowAgents: ["research"],
        model: "minimax/MiniMax-M2.7",
        maxConcurrent: 8,
        runTimeoutSeconds: 900,
        announceTimeoutMs: 120000,
        archiveAfterMinutes: 60,
      },
    },
  },
}

model : modèle par défaut pour les sous-agents générés. S’il est omis, les sous-agents héritent du modèle de l’appelant.
allowAgents : liste d’autorisation par défaut des identifiants d’agents cibles pour sessions_spawn lorsque l’agent demandeur ne définit pas son propre subagents.allowAgents (["*"] = n’importe lequel ; par défaut : même agent uniquement).
runTimeoutSeconds : délai d’expiration par défaut (en secondes) pour sessions_spawn lorsque l’appel d’outil omet runTimeoutSeconds. 0 signifie aucun délai d’expiration.
announceTimeoutMs : délai d’expiration par appel (en millisecondes) pour les tentatives de remise d’annonce agent du Gateway. Par défaut : 120000. Les nouvelles tentatives transitoires peuvent rendre l’attente totale de l’annonce plus longue qu’un délai d’expiration configuré.
Politique d’outils par sous-agent : tools.subagents.tools.allow / tools.subagents.tools.deny.

Fournisseurs personnalisés et URL de base

OpenClaw utilise le catalogue de modèles intégré. Ajoutez des fournisseurs personnalisés via models.providers dans la configuration ou ~/.openclaw/agents/<agentId>/agent/models.json.

{
  models: {
    mode: "merge", // merge (default) | replace
    providers: {
      "custom-proxy": {
        baseUrl: "http://localhost:4000/v1",
        apiKey: "LITELLM_KEY",
        api: "openai-completions", // openai-completions | openai-responses | anthropic-messages | google-generative-ai
        models: [
          {
            id: "llama-3.1-8b",
            name: "Llama 3.1 8B",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 128000,
            contextTokens: 96000,
            maxTokens: 32000,
          },
        ],
      },
    },
  },
}

Authentification et priorité de fusion

Utilisez authHeader: true + headers pour les besoins d’authentification personnalisés.
Remplacez la racine de configuration de l’agent avec OPENCLAW_AGENT_DIR (ou PI_CODING_AGENT_DIR, un alias hérité de variable d’environnement).
Priorité de fusion pour les ID de fournisseur correspondants :
- Les valeurs baseUrl non vides du models.json de l’agent l’emportent.
- Les valeurs apiKey non vides de l’agent l’emportent uniquement lorsque ce fournisseur n’est pas géré par SecretRef dans le contexte actuel de configuration/profil d’authentification.
- Les valeurs apiKey de fournisseur gérées par SecretRef sont actualisées depuis les marqueurs source (ENV_VAR_NAME pour les références d’environnement, secretref-managed pour les références fichier/exec) au lieu de persister les secrets résolus.
- Les valeurs d’en-tête de fournisseur gérées par SecretRef sont actualisées depuis les marqueurs source (secretref-env:ENV_VAR_NAME pour les références d’environnement, secretref-managed pour les références fichier/exec).
- Les apiKey/baseUrl d’agent vides ou manquants se replient sur models.providers dans la configuration.
- Les contextWindow/maxTokens de modèle correspondants utilisent la valeur la plus élevée entre les valeurs de configuration explicites et les valeurs implicites du catalogue.
- Les contextTokens de modèle correspondants préservent un plafond d’exécution explicite lorsqu’il est présent ; utilisez-les pour limiter le contexte effectif sans modifier les métadonnées natives du modèle.
- Utilisez models.mode: "replace" lorsque vous voulez que la configuration réécrive entièrement models.json.
- La persistance des marqueurs fait autorité côté source : les marqueurs sont écrits depuis l’instantané de configuration source actif (avant résolution), et non depuis les valeurs de secrets résolues à l’exécution.

Détails des champs de fournisseur

Catalogue de premier niveau

models.mode : comportement du catalogue de fournisseurs (merge ou replace).
models.providers : map de fournisseurs personnalisés indexée par ID de fournisseur.
- Modifications sûres : utilisez openclaw config set models.providers.<id> '<json>' --strict-json --merge ou openclaw config set models.providers.<id>.models '<json-array>' --strict-json --merge pour les mises à jour additives. config set refuse les remplacements destructifs sauf si vous passez --replace.

Connexion et authentification du fournisseur

models.providers.*.api : adaptateur de requête (openai-completions, openai-responses, anthropic-messages, google-generative-ai, etc.). Pour les backends /v1/chat/completions auto-hébergés tels que MLX, vLLM, SGLang et la plupart des serveurs locaux compatibles OpenAI, utilisez openai-completions. Un fournisseur personnalisé avec baseUrl mais sans api utilise par défaut openai-completions ; définissez openai-responses uniquement lorsque le backend prend en charge /v1/responses.
models.providers.*.apiKey : identifiant du fournisseur (préférez SecretRef/la substitution d’environnement).
models.providers.*.auth : stratégie d’authentification (api-key, token, oauth, aws-sdk).
models.providers.*.contextWindow : fenêtre de contexte native par défaut pour les modèles sous ce fournisseur lorsque l’entrée de modèle ne définit pas contextWindow.
models.providers.*.contextTokens : plafond de contexte effectif par défaut à l’exécution pour les modèles sous ce fournisseur lorsque l’entrée de modèle ne définit pas contextTokens.
models.providers.*.maxTokens : plafond de jetons de sortie par défaut pour les modèles sous ce fournisseur lorsque l’entrée de modèle ne définit pas maxTokens.
models.providers.*.timeoutSeconds : délai d’expiration facultatif, en secondes, des requêtes HTTP de modèle par fournisseur, incluant la connexion, les en-têtes, le corps et la gestion de l’abandon total de la requête.
models.providers.*.injectNumCtxForOpenAICompat : pour Ollama + openai-completions, injecte options.num_ctx dans les requêtes (par défaut : true).
models.providers.*.authHeader : force le transport des identifiants dans l’en-tête Authorization lorsque requis.
models.providers.*.baseUrl : URL de base de l’API amont.
models.providers.*.headers : en-têtes statiques supplémentaires pour le routage proxy/locataire.

Surcharges du transport de requête

models.providers.*.request : surcharges de transport pour les requêtes HTTP de fournisseur de modèles.

request.headers : en-têtes supplémentaires (fusionnés avec les valeurs par défaut du fournisseur). Les valeurs acceptent SecretRef.
request.auth : surcharge de stratégie d’authentification. Modes : "provider-default" (utiliser l’authentification intégrée du fournisseur), "authorization-bearer" (avec token), "header" (avec headerName, value, prefix facultatif).
request.proxy : surcharge de proxy HTTP. Modes : "env-proxy" (utiliser les variables d’environnement HTTP_PROXY/HTTPS_PROXY), "explicit-proxy" (avec url). Les deux modes acceptent un sous-objet tls facultatif.
request.tls : surcharge TLS pour les connexions directes. Champs : ca, cert, key, passphrase (tous acceptent SecretRef), serverName, insecureSkipVerify.
request.allowPrivateNetwork : lorsque true, autorise HTTPS vers baseUrl lorsque le DNS se résout vers des plages privées, CGNAT ou similaires, via la garde de récupération HTTP du fournisseur (adhésion explicite de l’opérateur pour les points de terminaison compatibles OpenAI auto-hébergés de confiance). Les URL de flux de fournisseur de modèles en local loopback telles que localhost, 127.0.0.1 et [::1] sont autorisées automatiquement, sauf si cette option est explicitement définie sur false ; les hôtes LAN, tailnet et DNS privés nécessitent toujours une adhésion explicite. WebSocket utilise le même request pour les en-têtes/TLS, mais pas cette barrière SSRF de fetch. Par défaut false.

Entrées du catalogue de modèles

Découverte Amazon Bedrock

plugins.entries.amazon-bedrock.config.discovery : racine des paramètres de découverte automatique Bedrock.
plugins.entries.amazon-bedrock.config.discovery.enabled : active/désactive la découverte implicite.
plugins.entries.amazon-bedrock.config.discovery.region : région AWS pour la découverte.
plugins.entries.amazon-bedrock.config.discovery.providerFilter : filtre facultatif d’ID de fournisseur pour une découverte ciblée.
plugins.entries.amazon-bedrock.config.discovery.refreshInterval : intervalle d’interrogation pour l’actualisation de la découverte.
plugins.entries.amazon-bedrock.config.discovery.defaultContextWindow : fenêtre de contexte de repli pour les modèles découverts.
plugins.entries.amazon-bedrock.config.discovery.defaultMaxTokens : nombre maximal de jetons de sortie de repli pour les modèles découverts.

L’onboarding interactif des fournisseurs personnalisés déduit la prise en charge des entrées image pour les ID de modèles de vision courants, tels que GPT-4o, Claude, Gemini, Qwen-VL, LLaVA, Pixtral, InternVL, Mllama, MiniCPM-V et GLM-4V, et ignore la question supplémentaire pour les familles connues comme étant uniquement textuelles. Les ID de modèles inconnus demandent toujours si les images sont prises en charge. L’onboarding non interactif utilise la même déduction ; passez --custom-image-input pour forcer les métadonnées compatibles avec les images ou --custom-text-input pour forcer les métadonnées textuelles uniquement.

Exemples de fournisseurs

Cerebras (GLM 4.7 / GPT OSS)

Le plugin fournisseur cerebras fourni peut configurer cela via openclaw onboard --auth-choice cerebras-api-key. N’utilisez une configuration de fournisseur explicite que lorsque vous remplacez les valeurs par défaut.

{
  env: { CEREBRAS_API_KEY: "sk-..." },
  agents: {
    defaults: {
      model: {
        primary: "cerebras/zai-glm-4.7",
        fallbacks: ["cerebras/gpt-oss-120b"],
      },
      models: {
        "cerebras/zai-glm-4.7": { alias: "GLM 4.7 (Cerebras)" },
        "cerebras/gpt-oss-120b": { alias: "GPT OSS 120B (Cerebras)" },
      },
    },
  },
  models: {
    mode: "merge",
    providers: {
      cerebras: {
        baseUrl: "https://api.cerebras.ai/v1",
        apiKey: "${CEREBRAS_API_KEY}",
        api: "openai-completions",
        models: [
          { id: "zai-glm-4.7", name: "GLM 4.7 (Cerebras)" },
          { id: "gpt-oss-120b", name: "GPT OSS 120B (Cerebras)" },
        ],
      },
    },
  },
}

Utilisez cerebras/zai-glm-4.7 pour Cerebras ; zai/glm-4.7 pour Z.AI direct.

Codage Kimi

{
  env: { KIMI_API_KEY: "sk-..." },
  agents: {
    defaults: {
      model: { primary: "kimi/kimi-for-coding" },
      models: { "kimi/kimi-for-coding": { alias: "Kimi Code" } },
    },
  },
}

Compatible avec Anthropic, fournisseur intégré. Raccourci : openclaw onboard --auth-choice kimi-code-api-key.

Modèles locaux (LM Studio)

Consultez Modèles locaux. En bref : exécutez un grand modèle local via l’API Responses de LM Studio sur du matériel sérieux ; conservez les modèles hébergés fusionnés pour le repli.

MiniMax M2.7 (direct)

{
  agents: {
    defaults: {
      model: { primary: "minimax/MiniMax-M2.7" },
      models: {
        "minimax/MiniMax-M2.7": { alias: "Minimax" },
      },
    },
  },
  models: {
    mode: "merge",
    providers: {
      minimax: {
        baseUrl: "https://api.minimax.io/anthropic",
        apiKey: "${MINIMAX_API_KEY}",
        api: "anthropic-messages",
        models: [
          {
            id: "MiniMax-M2.7",
            name: "MiniMax M2.7",
            reasoning: true,
            input: ["text"],
            cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0.375 },
            contextWindow: 204800,
            maxTokens: 131072,
          },
        ],
      },
    },
  },
}

Définissez MINIMAX_API_KEY. Raccourcis : openclaw onboard --auth-choice minimax-global-api ou openclaw onboard --auth-choice minimax-cn-api. Le catalogue de modèles utilise M2.7 uniquement par défaut. Sur le chemin de streaming compatible avec Anthropic, OpenClaw désactive la réflexion MiniMax par défaut, sauf si vous définissez explicitement thinking vous-même. /fast on ou params.fastMode: true réécrit MiniMax-M2.7 en MiniMax-M2.7-highspeed.

Moonshot AI (Kimi)

{
  env: { MOONSHOT_API_KEY: "sk-..." },
  agents: {
    defaults: {
      model: { primary: "moonshot/kimi-k2.6" },
      models: { "moonshot/kimi-k2.6": { alias: "Kimi K2.6" } },
    },
  },
  models: {
    mode: "merge",
    providers: {
      moonshot: {
        baseUrl: "https://api.moonshot.ai/v1",
        apiKey: "${MOONSHOT_API_KEY}",
        api: "openai-completions",
        models: [
          {
            id: "kimi-k2.6",
            name: "Kimi K2.6",
            reasoning: false,
            input: ["text", "image"],
            cost: { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 },
            contextWindow: 262144,
            maxTokens: 262144,
          },
        ],
      },
    },
  },
}

Pour le point de terminaison chinois : baseUrl: "https://api.moonshot.cn/v1" ou openclaw onboard --auth-choice moonshot-api-key-cn.Les points de terminaison natifs Moonshot annoncent une compatibilité d’utilisation en streaming sur le transport partagé openai-completions, et OpenClaw se fonde sur les capacités du point de terminaison plutôt que sur le seul ID de fournisseur intégré.

OpenCode

{
  agents: {
    defaults: {
      model: { primary: "opencode/claude-opus-4-6" },
      models: { "opencode/claude-opus-4-6": { alias: "Opus" } },
    },
  },
}

Définissez OPENCODE_API_KEY (ou OPENCODE_ZEN_API_KEY). Utilisez les références opencode/... pour le catalogue Zen ou les références opencode-go/... pour le catalogue Go. Raccourci : openclaw onboard --auth-choice opencode-zen ou openclaw onboard --auth-choice opencode-go.

Synthetic (compatible avec Anthropic)

{
  env: { SYNTHETIC_API_KEY: "sk-..." },
  agents: {
    defaults: {
      model: { primary: "synthetic/hf:MiniMaxAI/MiniMax-M2.5" },
      models: { "synthetic/hf:MiniMaxAI/MiniMax-M2.5": { alias: "MiniMax M2.5" } },
    },
  },
  models: {
    mode: "merge",
    providers: {
      synthetic: {
        baseUrl: "https://api.synthetic.new/anthropic",
        apiKey: "${SYNTHETIC_API_KEY}",
        api: "anthropic-messages",
        models: [
          {
            id: "hf:MiniMaxAI/MiniMax-M2.5",
            name: "MiniMax M2.5",
            reasoning: true,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 192000,
            maxTokens: 65536,
          },
        ],
      },
    },
  },
}

L’URL de base doit omettre /v1 (le client Anthropic l’ajoute). Raccourci : openclaw onboard --auth-choice synthetic-api-key.

Z.AI (GLM-4.7)

{
  agents: {
    defaults: {
      model: { primary: "zai/glm-4.7" },
      models: { "zai/glm-4.7": {} },
    },
  },
}

Définissez ZAI_API_KEY. z.ai/* et z-ai/* sont des alias acceptés. Raccourci : openclaw onboard --auth-choice zai-api-key.

Point de terminaison général : https://api.z.ai/api/paas/v4
Point de terminaison de codage (par défaut) : https://api.z.ai/api/coding/paas/v4
Pour le point de terminaison général, définissez un fournisseur personnalisé avec le remplacement de l’URL de base.

Connexe

Configuration — agents
Configuration — canaux
Référence de configuration — autres clés de premier niveau
Outils et plugins

Documentation Index

​Outils

​Profils d’outils

​Groupes d’outils

​tools.allow / tools.deny

​tools.byProvider

​tools.toolsBySender

​tools.elevated

​tools.exec

​tools.loopDetection

​tools.web

​tools.media

​tools.agentToAgent

​tools.sessions

​tools.sessions_spawn

​tools.experimental

​agents.defaults.subagents

​Fournisseurs personnalisés et URL de base

​Détails des champs de fournisseur

​Exemples de fournisseurs

​Connexe

Outils

Profils d’outils

Groupes d’outils

`tools.allow` / `tools.deny`

`tools.byProvider`

`tools.toolsBySender`

`tools.elevated`

`tools.exec`

`tools.loopDetection`

`tools.web`

`tools.media`

`tools.agentToAgent`

`tools.sessions`

`tools.sessions_spawn`

`tools.experimental`

`agents.defaults.subagents`

Fournisseurs personnalisés et URL de base

Détails des champs de fournisseur

Exemples de fournisseurs

Connexe