Fournisseurs de modèles

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

Règles rapides

Comportement de fournisseur détenu par le Plugin

La plupart de la logique propre à un fournisseur vit dans les plugins de fournisseur (registerProvider(...)) tandis qu’OpenClaw conserve la boucle d’inférence générique. Les plugins possèdent l’intégration initiale, les catalogues de modèles, le mappage des variables d’environnement d’authentification, la normalisation transport/configuration, le nettoyage des schémas d’outils, la classification de bascule, l’actualisation OAuth, le reporting d’utilisation, les profils de réflexion/raisonnement, et plus encore.

La liste complète des hooks du SDK fournisseur et des exemples de plugins groupés se trouve dans Plugins de fournisseur. Un fournisseur qui a besoin d’un exécuteur de requêtes totalement personnalisé relève d’une surface d’extension distincte et plus profonde.

Rotation des clés API

Plugins de fournisseur officiels

Les plugins de fournisseur officiels publient leurs propres lignes de catalogue de modèles. Ces fournisseurs ne nécessitent aucune entrée de modèle models.providers ; activez le plugin de fournisseur, définissez l’authentification et choisissez un modèle. Utilisez models.providers uniquement pour des fournisseurs personnalisés explicites ou des paramètres de requête étroits comme les délais d’expiration.

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 spécifique se comporte différemment.
• CLI : openclaw onboard --auth-choice openai-api-key
• Le transport par défaut est auto ; OpenClaw transmet le choix de transport au runtime de modèle partagé.
• Remplacez par modèle via agents.defaults.models["openai/<model>"].params.transport ("sse", "websocket" ou "auto")
• Le traitement prioritaire OpenAI peut être activé via agents.defaults.models["openai/<model>"].params.serviceTier
• /fast et params.fastMode mappent les requêtes Responses directes openai/* vers service_tier=priority sur api.openai.com
• Utilisez params.serviceTier lorsque vous voulez un niveau explicite au lieu du basculeur /fast partagé
• 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 aussi store de Responses, les indications de cache de prompt et la mise en forme de charge utile compatible avec le raisonnement OpenAI ; les routes proxy ne le font pas
• openai/gpt-5.3-codex-spark est disponible via l’authentification d’abonnement OAuth ChatGPT/Codex lorsque votre compte connecté l’expose ; OpenClaw supprime toujours les routes directes par clé API OpenAI et clé API Azure pour ce modèle, car ces transports le rejettent

{  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 /fast partagé et params.fastMode, y compris le trafic authentifié par clé API et OAuth envoyé à api.anthropic.com ; OpenClaw mappe cela vers le 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-8 avec le agentRuntime.id: "claude-cli" scoped au modèle. Les références héritées claude-cli/claude-opus-4-7 fonctionnent toujours pour compatibilité.

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

OAuth OpenAI ChatGPT/Codex

• Fournisseur : openai
• Authentification : OAuth (ChatGPT)
• Référence de modèle OpenAI Codex héritée : openai/gpt-5.5
• Référence du harnais natif de serveur d’application Codex : openai/gpt-5.5
• Documentation du harnais natif de serveur d’application Codex : Harnais Codex
• Références de modèles héritées : codex/gpt-*
• Frontière de plugin : openai/* charge le plugin OpenAI ; le plugin natif de serveur d’application Codex est sélectionné par le runtime du harnais Codex.
• CLI : openclaw onboard --auth-choice openai ou openclaw models auth login --provider openai
• Le transport par défaut est auto (WebSocket d’abord, repli SSE)
• Remplacez par modèle OpenAI Codex via agents.defaults.models["openai/<model>"].params.transport ("sse", "websocket" ou "auto")
• params.serviceTier est aussi 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 attachés qu’au trafic Codex natif vers chatgpt.com/backend-api, pas aux proxys génériques compatibles OpenAI
• Partage le même basculeur /fast et la même configuration params.fastMode que openai/* direct ; OpenClaw mappe cela vers service_tier=priority
• openai/gpt-5.5 utilise le contextWindow = 400000 natif du catalogue Codex et le runtime par défaut contextTokens = 272000 ; remplacez le plafond du runtime avec models.providers.openai.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 et configurez openai/gpt-5.5 ; les tours d’agent OpenAI sélectionnent Codex par défaut.
• Utilisez le agentRuntime.id: "openclaw" fournisseur/modèle uniquement lorsque vous voulez la route intégrée OpenClaw ; sinon, conservez openai/gpt-5.5 sur le harnais Codex par défaut.
• les références GPT Codex héritées sont un état hérité, pas une route de fournisseur live. Utilisez openai/gpt-5.5 sur le runtime Codex natif pour les nouvelles configurations d’agent, et exécutez openclaw doctor --fix pour migrer les anciennes références de modèles Codex héritées vers des références canoniques openai/*.

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

{  models: {    providers: {      openai: {        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 du runtime Zen : opencode
• Fournisseur du 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 (surcharge unique)
• Modèles d’exemple : google/gemini-3.1-pro-preview, google/gemini-3-flash-preview
• Compatibilité : l’ancienne configuration OpenClaw 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’ID d’API Gemini live 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 omet 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’ancien cached_content) pour transférer un identifiant natif du fournisseur cachedContents/... ; les succès de cache Gemini apparaissent sous forme de cacheRead OpenClaw

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 livré dans le cadre du Plugin google intégré.

brew install gemini-cli

npm install -g @google/gemini-cli

openclaw plugins enable google

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

Gemini CLI utilise stream-json par défaut. OpenClaw lit les messages de flux de l’assistant et normalise stats.cached en cacheRead ; les anciennes surcharges --output-format json lisent encore le texte de réponse depuis response.

Z.AI (GLM)

• Fournisseur : zai
• Authentification : ZAI_API_KEY
• Modèle d’exemple : zai/glm-5.2
• CLI : openclaw onboard --auth-choice zai-api-key
  • Les références de modèles utilisent l’ID de fournisseur canonique 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

Autres Plugins de fournisseurs intégrés

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 de fournisseurs intégrés 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 des modèles par défaut.

Les vérifications de capacités des modèles 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 provenant de node transmettent les images comme entrées natives du modèle au lieu de références multimédias en texte seul.

agents.defaults.models["provider/model"] contrôle uniquement la visibilité des modèles, les alias et les métadonnées par modèle pour les agents. Il n’enregistre pas à lui seul un nouveau modèle d’exécution. Pour les modèles de fournisseur personnalisés, ajoutez également models.providers.<provider>.models[] avec au moins l’id correspondant.

Moonshot AI (Kimi)

Installez @openclaw/moonshot-provider avant la configuration initiale. Ajoutez une entrée explicite models.providers.moonshot uniquement lorsque vous devez remplacer l’URL de base ou les métadonnées du 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

IDs de modèles Kimi K2 :

• moonshot/kimi-k2.6
• moonshot/kimi-k2.7-code
• 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" }],      },    },  },}

Programmation avec Kimi

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

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

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

Les anciens kimi/kimi-code et kimi/k2p5 restent acceptés comme IDs de modèles de compatibilité et sont normalisés vers l’ID de modèle d’API stable de Kimi.

Volcano Engine (Doubao)

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

• Fournisseur : volcengine (programmation : 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’onboarding 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’onboarding/configuration, le choix d’authentification Volcengine privilégie à la fois les lignes volcengine/* et volcengine-plan/*. Si ces modèles ne sont pas encore chargés, OpenClaw se rabat sur le catalogue non filtré au lieu d’afficher un sélecteur limité au fournisseur vide.

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’onboarding 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’onboarding/configuration, le choix d’authentification BytePlus privilégie à la fois les lignes byteplus/* et byteplus-plan/*. Si ces modèles ne sont pas encore chargés, OpenClaw se rabat sur le catalogue non filtré au lieu d’afficher un sélecteur limité au fournisseur vide.

Synthetic

Synthetic fournit des modèles compatibles avec 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 est configuré 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é API MiniMax (Global) : --auth-choice minimax-global-api
• Clé 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-M3
• 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 fourni comme Plugin de fournisseur intégré 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 possèdent le cycle de vie du modèle, définissez models.providers.lmstudio.params.preload: false. Consultez /providers/lmstudio pour la configuration et le dépannage.

Ollama

Ollama est fourni comme Plugin de fournisseur intégré 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 intégré ajoute Ollama directement à openclaw onboard et au sélecteur de modèles. Consultez /providers/ollama pour l’onboarding, le mode cloud/local et la configuration personnalisée.

vLLM

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

• Fournisseur : vllm
• Authentification : facultative (selon 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 fonctionne 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 fourni comme Plugin de fournisseur intégré pour les serveurs rapides auto-hébergés compatibles OpenAI :

• Fournisseur : sglang
• Authentification : facultative (selon 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 fonctionne 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-zenopenclaw models set opencode/claude-opus-4-6openclaw models list

Voir aussi : Configuration pour des exemples de configuration complets.

Liens connexes

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