Fournisseurs de modèles

Référence pour les fournisseurs LLM/modèles (pas les canaux de chat comme WhatsApp/Telegram). Pour les règles de sélection de modèles, consultez Modèles.

# Règles rapides

# Comportement fournisseur détenu par le Plugin

La plupart de la logique propre aux fournisseurs réside dans les Plugins fournisseurs (registerProvider(...)), tandis qu’OpenClaw conserve la boucle d’inférence générique. Les Plugins détiennent l’onboarding, les catalogues de modèles, la correspondance des variables d’environnement d’authentification, la normalisation transport/config, le nettoyage des schémas d’outils, la classification du basculement, le rafraîchissement OAuth, le reporting d’utilisation, les profils de pensée/raisonnement, et plus encore.

La liste complète des hooks SDK fournisseur et des exemples de Plugins intégrés se trouve dans Plugins fournisseurs. Un fournisseur qui nécessite un exécuteur de requêtes totalement personnalisé relève d’une surface d’extension distincte et plus profonde.

# Rotation des clés API

# Fournisseurs intégrés (catalogue pi-ai)

OpenClaw est livré avec le catalogue pi-ai. Ces fournisseurs ne nécessitent aucune configuration models.providers ; définissez simplement l’authentification et choisissez un modèle.

# OpenAI

• Fournisseur : openai
• Authentification : OPENAI_API_KEY
• Rotation facultative : OPENAI_API_KEYS, OPENAI_API_KEY_1, OPENAI_API_KEY_2, plus OPENCLAW_LIVE_OPENAI_KEY (remplacement unique)
• Exemples de modèles : openai/gpt-5.5, openai/gpt-5.4-mini
• Vérifiez la disponibilité du compte/modèle avec openclaw models list --provider openai si une installation ou une clé API précise se comporte différemment.
• CLI : openclaw onboard --auth-choice openai-api-key
• Le transport par défaut est auto (WebSocket d’abord, repli SSE)
• Remplacement par modèle via agents.defaults.models["openai/<model>"].params.transport ("sse", "websocket" ou "auto")
• Le préchauffage WebSocket OpenAI Responses est activé par défaut via params.openaiWsWarmup (true/false)
• Le traitement prioritaire OpenAI peut être activé via agents.defaults.models["openai/<model>"].params.serviceTier
• /fast et params.fastMode associent les requêtes Responses directes openai/* à service_tier=priority sur api.openai.com
• Utilisez params.serviceTier lorsque vous voulez un niveau explicite plutôt que le basculeur partagé /fast
• Les en-têtes d’attribution OpenClaw masqués (originator, version, User-Agent) s’appliquent uniquement au trafic OpenAI natif vers api.openai.com, pas aux proxys génériques compatibles OpenAI
• Les routes OpenAI natives conservent également store de Responses, les indications de cache de prompt et la mise en forme de payload compatible avec le raisonnement OpenAI ; les routes proxy ne le font pas
• openai/gpt-5.3-codex-spark est volontairement supprimé dans OpenClaw, car les requêtes live à l’API OpenAI le rejettent et le catalogue Codex actuel ne l’expose pas

{
  agents: { defaults: { model: { primary: "openai/gpt-5.5" } } },
}

# Anthropic

• Fournisseur : anthropic
• Authentification : ANTHROPIC_API_KEY
• Rotation facultative : ANTHROPIC_API_KEYS, ANTHROPIC_API_KEY_1, ANTHROPIC_API_KEY_2, plus OPENCLAW_LIVE_ANTHROPIC_KEY (remplacement unique)
• Exemple de modèle : anthropic/claude-opus-4-6
• CLI : openclaw onboard --auth-choice apiKey
• Les requêtes Anthropic publiques directes prennent en charge le basculeur partagé /fast et params.fastMode, y compris le trafic authentifié par clé API et OAuth envoyé à api.anthropic.com ; OpenClaw l’associe au service_tier Anthropic (auto contre standard_only)
• La configuration Claude CLI préférée conserve la référence de modèle canonique et sélectionne le backend CLI séparément : anthropic/claude-opus-4-7 avec agents.defaults.agentRuntime.id: "claude-cli". Les références historiques claude-cli/claude-opus-4-7 fonctionnent toujours pour la compatibilité.

{
  agents: { defaults: { model: { primary: "anthropic/claude-opus-4-6" } } },
}

# OpenAI Codex OAuth

• Fournisseur : openai-codex
• Authentification : OAuth (ChatGPT)
• Référence de modèle PI : openai-codex/gpt-5.5
• Référence du harnais natif de serveur d’application Codex : openai/gpt-5.5 avec agents.defaults.agentRuntime.id: "codex"
• Documentation du harnais natif de serveur d’application Codex : Harnais Codex
• Références de modèles historiques : codex/gpt-*
• Limite de Plugin : openai-codex/* charge le Plugin OpenAI ; le Plugin natif de serveur d’application Codex n’est sélectionné que par le runtime de harnais Codex ou les références historiques codex/*.
• CLI : openclaw onboard --auth-choice openai-codex ou openclaw models auth login --provider openai-codex
• Le transport par défaut est auto (WebSocket d’abord, repli SSE)
• Remplacement par modèle PI via agents.defaults.models["openai-codex/<model>"].params.transport ("sse", "websocket" ou "auto")
• params.serviceTier est également transmis sur les requêtes Responses Codex natives (chatgpt.com/backend-api)
• Les en-têtes d’attribution OpenClaw masqués (originator, version, User-Agent) ne sont ajoutés que sur le trafic Codex natif vers chatgpt.com/backend-api, pas aux proxys génériques compatibles OpenAI
• Partage la même configuration de basculeur /fast et params.fastMode que openai/* direct ; OpenClaw l’associe à service_tier=priority
• openai-codex/gpt-5.5 utilise le contextWindow = 400000 natif du catalogue Codex et le runtime par défaut contextTokens = 272000 ; remplacez le plafond de runtime avec models.providers.openai-codex.models[].contextTokens
• Note de politique : OpenAI Codex OAuth est explicitement pris en charge pour les outils/workflows externes comme OpenClaw.
• Pour la route courante abonnement plus runtime Codex natif, connectez-vous avec l’authentification openai-codex mais configurez openai/gpt-5.5 plus agents.defaults.agentRuntime.id: "codex".
• Utilisez openai-codex/gpt-5.5 uniquement lorsque vous voulez la route OAuth/abonnement Codex via PI ; utilisez openai/gpt-5.5 sans le remplacement du runtime Codex lorsque votre configuration par clé API et votre catalogue local exposent la route d’API publique.
• Les anciennes références openai-codex/gpt-5.1*, openai-codex/gpt-5.2* et openai-codex/gpt-5.3* sont supprimées, car les comptes ChatGPT/Codex OAuth les rejettent ; utilisez plutôt openai-codex/gpt-5.5 ou la route de runtime Codex native.

{
  plugins: { entries: { codex: { enabled: true } } },
  agents: {
    defaults: {
      model: { primary: "openai/gpt-5.5" },
      agentRuntime: { id: "codex" },
    },
  },
}

{
  models: {
    providers: {
      "openai-codex": {
        models: [{ id: "gpt-5.5", contextTokens: 160000 }],
      },
    },
  },
}

# Autres options hébergées de type abonnement

# OpenCode

• Authentification : OPENCODE_API_KEY (ou OPENCODE_ZEN_API_KEY)
• Fournisseur de runtime Zen : opencode
• Fournisseur de runtime Go : opencode-go
• Exemples de modèles : opencode/claude-opus-4-6, opencode-go/kimi-k2.6
• CLI : openclaw onboard --auth-choice opencode-zen ou openclaw onboard --auth-choice opencode-go

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

# Google Gemini (clé API)

• Fournisseur : google
• Authentification : GEMINI_API_KEY
• Rotation facultative : GEMINI_API_KEYS, GEMINI_API_KEY_1, GEMINI_API_KEY_2, repli GOOGLE_API_KEY, et OPENCLAW_LIVE_GEMINI_KEY (remplacement unique)
• Modèles d’exemple : google/gemini-3.1-pro-preview, google/gemini-3-flash-preview
• Compatibilité : la configuration OpenClaw héritée utilisant google/gemini-3.1-flash-preview est normalisée en google/gemini-3-flash-preview
• Alias : google/gemini-3.1-pro est accepté et normalisé vers l’identifiant Gemini API actif de Google, google/gemini-3.1-pro-preview
• CLI : openclaw onboard --auth-choice gemini-api-key
• Réflexion : /think adaptive utilise la réflexion dynamique de Google. Gemini 3/3.1 omettent un thinkingLevel fixe ; Gemini 2.5 envoie thinkingBudget: -1.
• Les exécutions Gemini directes acceptent aussi agents.defaults.models["google/<model>"].params.cachedContent (ou l’héritage cached_content) pour transmettre un identifiant natif du fournisseur cachedContents/... ; les lectures du cache Gemini apparaissent dans OpenClaw sous forme de cacheRead

# Google Vertex et Gemini CLI

• Fournisseurs : google-vertex, google-gemini-cli
• Authentification : Vertex utilise gcloud ADC ; Gemini CLI utilise son flux OAuth

Gemini CLI OAuth est fourni dans le cadre du plugin google inclus.

brew install gemini-cli

npm install -g @google/gemini-cli

openclaw plugins enable google

openclaw models auth login --provider google-gemini-cli --set-default

Les réponses JSON de Gemini CLI sont analysées depuis response ; l’utilisation se rabat sur stats, avec stats.cached normalisé en cacheRead OpenClaw.

# Z.AI (GLM)

• Fournisseur : zai
• Authentification : ZAI_API_KEY
• Modèle d’exemple : zai/glm-5.1
• CLI : openclaw onboard --auth-choice zai-api-key
  • Alias : z.ai/* et z-ai/* sont normalisés en zai/*
  • zai-api-key détecte automatiquement le point de terminaison Z.AI correspondant ; zai-coding-global, zai-coding-cn, zai-global et zai-cn forcent une surface spécifique

# Vercel AI Gateway

• Fournisseur : vercel-ai-gateway
• Authentification : AI_GATEWAY_API_KEY
• Modèles d’exemple : vercel-ai-gateway/anthropic/claude-opus-4.6, vercel-ai-gateway/moonshotai/kimi-k2.6
• CLI : openclaw onboard --auth-choice ai-gateway-api-key

# Kilo Gateway

• Fournisseur : kilocode
• Authentification : KILOCODE_API_KEY
• Modèle d’exemple : kilocode/kilo/auto
• CLI : openclaw onboard --auth-choice kilocode-api-key
• URL de base : https://api.kilo.ai/api/gateway/
• Le catalogue de repli statique inclut kilocode/kilo/auto ; la découverte active via https://api.kilo.ai/api/gateway/models peut étendre davantage le catalogue d’exécution.
• Le routage amont exact derrière kilocode/kilo/auto appartient à Kilo Gateway et n’est pas codé en dur dans OpenClaw.

Consultez /providers/kilocode pour les détails de configuration.

# Autres plugins de fournisseurs inclus

# Particularités à connaître

# Fournisseurs via models.providers (URL personnalisée/de base)

Utilisez models.providers (ou models.json) pour ajouter des fournisseurs personnalisés ou des proxys compatibles OpenAI/Anthropic.

Beaucoup des Plugins fournisseurs inclus ci-dessous publient déjà un catalogue par défaut. Utilisez des entrées explicites models.providers.<id> uniquement lorsque vous voulez remplacer l’URL de base, les en-têtes ou la liste de modèles par défaut.

Les vérifications de capacités de modèle du Gateway lisent aussi les métadonnées explicites models.providers.<id>.models[]. Si un modèle personnalisé ou proxy accepte les images, définissez input: ["text", "image"] sur ce modèle afin que WebChat et les chemins de pièces jointes d’origine nœud transmettent les images comme entrées natives de modèle au lieu de références multimédias en texte seul.

# Moonshot AI (Kimi)

Moonshot est livré comme Plugin fournisseur inclus. Utilisez le fournisseur intégré par défaut, et ajoutez une entrée explicite models.providers.moonshot uniquement lorsque vous devez remplacer l’URL de base ou les métadonnées de modèle :

• Fournisseur : moonshot
• Authentification : MOONSHOT_API_KEY
• Exemple de modèle : moonshot/kimi-k2.6
• CLI : openclaw onboard --auth-choice moonshot-api-key ou openclaw onboard --auth-choice moonshot-api-key-cn

Identifiants de modèles Kimi K2 :

• moonshot/kimi-k2.6
• moonshot/kimi-k2.5
• moonshot/kimi-k2-thinking
• moonshot/kimi-k2-thinking-turbo
• moonshot/kimi-k2-turbo

{
  agents: {
    defaults: { model: { primary: "moonshot/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" }],
      },
    },
  },
}

# Codage Kimi

Kimi Coding utilise le point de terminaison compatible Anthropic de Moonshot AI :

• Fournisseur : kimi
• Authentification : KIMI_API_KEY
• Exemple de modèle : kimi/kimi-code

{
  env: { KIMI_API_KEY: "sk-..." },
  agents: {
    defaults: { model: { primary: "kimi/kimi-code" } },
  },
}

L’ancien kimi/k2p5 reste accepté comme identifiant de modèle de compatibilité.

# Volcano Engine (Doubao)

Volcano Engine (火山引擎) donne accès à Doubao et à d’autres modèles en Chine.

• Fournisseur : volcengine (codage : volcengine-plan)
• Authentification : VOLCANO_ENGINE_API_KEY
• Exemple de modèle : volcengine-plan/ark-code-latest
• CLI : openclaw onboard --auth-choice volcengine-api-key

{
  agents: {
    defaults: { model: { primary: "volcengine-plan/ark-code-latest" } },
  },
}

L’intégration utilise par défaut la surface de codage, mais le catalogue général volcengine/* est enregistré en même temps.

Dans les sélecteurs de modèles d’intégration/configuration, le choix d’authentification Volcengine privilégie les lignes volcengine/* et volcengine-plan/*. Si ces modèles ne sont pas encore chargés, OpenClaw revient au catalogue non filtré au lieu d’afficher un sélecteur vide limité au fournisseur.

# BytePlus (International)

BytePlus ARK donne accès aux mêmes modèles que Volcano Engine pour les utilisateurs internationaux.

• Fournisseur : byteplus (codage : byteplus-plan)
• Authentification : BYTEPLUS_API_KEY
• Exemple de modèle : byteplus-plan/ark-code-latest
• CLI : openclaw onboard --auth-choice byteplus-api-key

{
  agents: {
    defaults: { model: { primary: "byteplus-plan/ark-code-latest" } },
  },
}

L’intégration utilise par défaut la surface de codage, mais le catalogue général byteplus/* est enregistré en même temps.

Dans les sélecteurs de modèles d’intégration/configuration, le choix d’authentification BytePlus privilégie les lignes byteplus/* et byteplus-plan/*. Si ces modèles ne sont pas encore chargés, OpenClaw revient au catalogue non filtré au lieu d’afficher un sélecteur vide limité au fournisseur.

# Synthetic

Synthetic fournit des modèles compatibles Anthropic derrière le fournisseur synthetic :

• Fournisseur : synthetic
• Authentification : SYNTHETIC_API_KEY
• Exemple de modèle : synthetic/hf:MiniMaxAI/MiniMax-M2.5
• CLI : openclaw onboard --auth-choice synthetic-api-key

{
  agents: {
    defaults: { model: { primary: "synthetic/hf:MiniMaxAI/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" }],
      },
    },
  },
}

# MiniMax

MiniMax se configure via models.providers, car il utilise des points de terminaison personnalisés :

• MiniMax OAuth (Global) : --auth-choice minimax-global-oauth
• MiniMax OAuth (CN) : --auth-choice minimax-cn-oauth
• Clé d’API MiniMax (Global) : --auth-choice minimax-global-api
• Clé d’API MiniMax (CN) : --auth-choice minimax-cn-api
• Authentification : MINIMAX_API_KEY pour minimax ; MINIMAX_OAUTH_TOKEN ou MINIMAX_API_KEY pour minimax-portal

Consultez /providers/minimax pour les détails de configuration, les options de modèles et les extraits de configuration.

Répartition des capacités détenue par le Plugin :

• Les valeurs par défaut texte/chat restent sur minimax/MiniMax-M2.7
• La génération d’images est minimax/image-01 ou minimax-portal/image-01
• La compréhension d’images est MiniMax-VL-01, détenue par le Plugin, sur les deux chemins d’authentification MiniMax
• La recherche web reste sur l’identifiant de fournisseur minimax

# LM Studio

LM Studio est livré comme Plugin de fournisseur groupé qui utilise l’API native :

• Fournisseur : lmstudio
• Authentification : LM_API_TOKEN
• URL de base d’inférence par défaut : http://localhost:1234/v1

Définissez ensuite un modèle (remplacez par l’un des identifiants renvoyés par http://localhost:1234/api/v1/models) :

{
  agents: {
    defaults: { model: { primary: "lmstudio/openai/gpt-oss-20b" } },
  },
}

OpenClaw utilise les points de terminaison natifs /api/v1/models et /api/v1/models/load de LM Studio pour la découverte et le chargement automatique, avec /v1/chat/completions pour l’inférence par défaut. Si vous voulez que le chargement JIT, le TTL et l’éviction automatique de LM Studio gèrent le cycle de vie des modèles, définissez models.providers.lmstudio.params.preload: false. Consultez /providers/lmstudio pour la configuration et le dépannage.

# Ollama

Ollama est livré comme Plugin de fournisseur groupé et utilise l’API native d’Ollama :

• Fournisseur : ollama
• Authentification : aucune requise (serveur local)
• Exemple de modèle : ollama/llama3.3
• Installation : https://ollama.com/download

# Install Ollama, then pull a model:
ollama pull llama3.3

{
  agents: {
    defaults: { model: { primary: "ollama/llama3.3" } },
  },
}

Ollama est détecté localement à http://127.0.0.1:11434 lorsque vous l’activez avec OLLAMA_API_KEY, et le Plugin de fournisseur groupé ajoute Ollama directement à openclaw onboard et au sélecteur de modèles. Consultez /providers/ollama pour l’intégration, le mode cloud/local et la configuration personnalisée.

# vLLM

vLLM est livré comme Plugin de fournisseur groupé pour les serveurs locaux/auto-hébergés compatibles OpenAI :

• Fournisseur : vllm
• Authentification : facultative (dépend de votre serveur)
• URL de base par défaut : http://127.0.0.1:8000/v1

Pour activer la découverte automatique localement (n’importe quelle valeur convient si votre serveur n’impose pas l’authentification) :

export VLLM_API_KEY="vllm-local"

Définissez ensuite un modèle (remplacez par l’un des identifiants renvoyés par /v1/models) :

{
  agents: {
    defaults: { model: { primary: "vllm/your-model-id" } },
  },
}

Consultez /providers/vllm pour plus de détails.

# SGLang

SGLang est livré comme Plugin de fournisseur groupé pour les serveurs rapides auto-hébergés compatibles OpenAI :

• Fournisseur : sglang
• Authentification : facultative (dépend de votre serveur)
• URL de base par défaut : http://127.0.0.1:30000/v1

Pour activer la découverte automatique localement (n’importe quelle valeur convient si votre serveur n’impose pas l’authentification) :

export SGLANG_API_KEY="sglang-local"

Définissez ensuite un modèle (remplacez par l’un des identifiants renvoyés par /v1/models) :

{
  agents: {
    defaults: { model: { primary: "sglang/your-model-id" } },
  },
}

Consultez /providers/sglang pour plus de détails.

# Proxys locaux (LM Studio, vLLM, LiteLLM, etc.)

Exemple (compatible OpenAI) :

{
  agents: {
    defaults: {
      model: { primary: "lmstudio/my-local-model" },
      models: { "lmstudio/my-local-model": { alias: "Local" } },
    },
  },
  models: {
    providers: {
      lmstudio: {
        baseUrl: "http://localhost:1234/v1",
        apiKey: "${LM_API_TOKEN}",
        api: "openai-completions",
        timeoutSeconds: 300,
        models: [
          {
            id: "my-local-model",
            name: "Local Model",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            contextWindow: 200000,
            maxTokens: 8192,
          },
        ],
      },
    },
  },
}

# Exemples CLI

openclaw onboard --auth-choice opencode-zen
openclaw models set opencode/claude-opus-4-6
openclaw models list

Voir aussi : Configuration pour des exemples de configuration complets.

# Connexe

• Référence de configuration - clés de configuration des modèles
• Basculement de modèle - chaînes de repli et comportement de nouvelle tentative
• Modèles - configuration des modèles et alias
• Fournisseurs - guides de configuration par fournisseur