Fournisseurs de modèles

Référence pour les fournisseurs de LLM/modèles (pas les canaux de discussion 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 un 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, la correspondance des variables d’environnement d’authentification, la normalisation du transport/de la configuration, le nettoyage des schémas d’outils, la classification du basculement, l’actualisation OAuth, les rapports d’utilisation, les profils de réflexion/raisonnement, et plus encore.

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

Rotation des clés d’API

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

OpenClaw est fourni 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é d’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 à pi-ai.
• Remplacez-le 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 font correspondre les requêtes Responses directes openai/* à 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, et non aux proxys génériques compatibles OpenAI
• Les routes OpenAI natives conservent aussi les champs Responses store, 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 intentionnellement supprimé dans OpenClaw, car les requêtes API OpenAI live 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 /fast partagé et params.fastMode, y compris le trafic authentifié par clé d’API et par OAuth envoyé à api.anthropic.com ; OpenClaw fait correspondre cela au service_tier d’Anthropic (auto contre standard_only)
• La configuration Claude CLI privilégié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 agentRuntime.id: "claude-cli" limité au modèle. Les références héritées claude-cli/claude-opus-4-7 continuent de fonctionner pour la compatibilité.

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

OAuth OpenAI Codex

• Fournisseur : openai-codex
• Authentification : OAuth (ChatGPT)
• Référence de modèle PI héritée : openai-codex/gpt-5.5
• Référence du harnais serveur d’application Codex natif : openai/gpt-5.5
• Documentation du harnais serveur d’application Codex natif : Harnais Codex
• Références de modèle héritées : codex/gpt-*
• Limite de Plugin : openai-codex/* charge le Plugin OpenAI ; le Plugin de serveur d’application Codex natif n’est sélectionné que par le runtime du harnais Codex ou par les références héritées 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, SSE en repli)
• Remplacez-le par modèle PI via agents.defaults.models["openai-codex/<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 joints qu’au trafic Codex natif vers chatgpt.com/backend-api, et non aux proxys génériques compatibles OpenAI
• Partage la même configuration de basculeur /fast et params.fastMode que openai/* direct ; OpenClaw fait correspondre cela à 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 du runtime avec models.providers.openai-codex.models[].contextTokens
• Note de politique : OAuth OpenAI Codex est explicitement pris en charge pour les outils/flux de travail externes comme OpenClaw.
• Pour la route courante avec abonnement et runtime Codex natif, connectez-vous avec l’authentification openai-codex, mais configurez openai/gpt-5.5 ; les tours d’agent OpenAI sélectionnent Codex par défaut.
• Utilisez le agentRuntime.id: "pi" fournisseur/modèle uniquement lorsque vous voulez une route de compatibilité via PI ; sinon, conservez openai/gpt-5.5 sur le harnais Codex par défaut.
• 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" },    },  },}

{  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 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é d’API)

• Fournisseur : google
• Authentification : GEMINI_API_KEY
• Rotation facultative : GEMINI_API_KEYS, GEMINI_API_KEY_1, GEMINI_API_KEY_2, solution de repli GOOGLE_API_KEY et OPENCLAW_LIVE_GEMINI_KEY (substitution unique)
• Exemples de modèles : 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 omet un thinkingLevel fixe ; Gemini 2.5 envoie thinkingBudget: -1.
• Les exécutions Gemini directes acceptent également agents.defaults.models["google/<model>"].params.cachedContent (ou l’héritage cached_content) pour transférer un handle cachedContents/... natif du fournisseur ; les succès de cache Gemini apparaissent comme 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 fourni dans le cadre du Plugin google groupé.

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
• Exemple de modèle : 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 imposent une surface spécifique

Vercel AI Gateway

• Fournisseur : vercel-ai-gateway
• Authentification : AI_GATEWAY_API_KEY
• Exemples de modèles : 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
• Exemple de modèle : kilocode/kilo/auto
• CLI : openclaw onboard --auth-choice kilocode-api-key
• URL de base : https://api.kilo.ai/api/gateway/
• Le catalogue statique de repli fournit kilocode/kilo/auto ; la découverte active 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, il n’est pas codé en dur dans OpenClaw.

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

Autres Plugins de fournisseurs groupé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.

Un grand nombre des plugins 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é 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 des nœuds transmettent les images comme entrées de modèle natives plutôt que comme références multimédias 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 aussi models.providers.<provider>.models[] avec au moins l’id correspondant.

Moonshot AI (Kimi)

Moonshot est livré comme plugin fournisseur intégré. 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 du modèle :

• Fournisseur : moonshot
• Authentification : MOONSHOT_API_KEY
• Modèle d’exemple : moonshot/kimi-k2.6
• CLI : openclaw onboard --auth-choice moonshot-api-key ou openclaw onboard --auth-choice moonshot-api-key-cn

ID des 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 endpoint compatible Anthropic de Moonshot AI :

• Provider : kimi
• Auth : 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èle 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.

• Provider : volcengine (codage : volcengine-plan)
• Auth : 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 revient au catalogue non filtré au lieu d’afficher un sélecteur limité au fournisseur et vide.

BytePlus (international)

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

• Provider : byteplus (codage : byteplus-plan)
• Auth : 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 revient au catalogue non filtré au lieu d’afficher un sélecteur limité au fournisseur et vide.

Synthetic

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

• Provider : synthetic
• Auth : 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 endpoints 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
• Auth : 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 gérée 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 le MiniMax-VL-01 géré par le Plugin sur les deux chemins d’authentification MiniMax
• La recherche Web reste sur l’id de provider minimax

LM Studio

LM Studio est fourni comme Plugin de provider intégré qui utilise l’API native :

• Provider : lmstudio
• Auth : 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 IDs renvoyés par http://localhost:1234/api/v1/models) :

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

OpenClaw utilise les endpoints 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 provider intégré et utilise l’API native d’Ollama :

• Provider : ollama
• Auth : 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 provider intégré ajoute Ollama directement à openclaw onboard et au sélecteur de modèle. Consultez /providers/ollama pour l’onboarding, le mode cloud/local et la configuration personnalisée.

vLLM

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

• Provider : vllm
• Auth : 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 en local (n’importe quelle valeur fonctionne si votre serveur n’impose pas d’authentification) :

export VLLM_API_KEY="vllm-local"

Définissez ensuite un modèle (remplacez par l’un des IDs 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 provider intégré pour les serveurs rapides auto-hébergés compatibles OpenAI :

• Provider : sglang
• Auth : 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 en local (n’importe quelle valeur fonctionne si votre serveur n’impose pas d’authentification) :

export SGLANG_API_KEY="sglang-local"

Définissez ensuite un modèle (remplacez par l’un des IDs 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.

Connexe

• 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
• Providers - guides de configuration par provider