---
read_when:
- Vous souhaitez utiliser les modèles OpenAI dans OpenClaw
- Vous voulez l’authentification par abonnement Codex au lieu de clés API
- Vous avez besoin d’un comportement d’exécution d’agent GPT-5 plus strict
summary: Utiliser OpenAI via des clés API ou un abonnement Codex dans OpenClaw
title: OpenAI
x-i18n:
generated_at: "2026-07-01T08:01:30Z"
model: gpt-5.5
postprocess_version: locale-links-v1
provider: openai
source_hash: 7078798b1d73bd1efca4820eae6d3fb6510e802b2c9193d0c135d8ab28c58fca
source_path: providers/openai.md
workflow: 16
---
OpenAI fournit des API développeur pour les modèles GPT, et Codex est également disponible comme
agent de codage de forfait ChatGPT via les clients Codex d'OpenAI. OpenClaw utilise un seul
identifiant de provider, `openai`, pour les deux formes d'authentification.
OpenClaw utilise `openai/*` comme route canonique des modèles OpenAI. Les tours d'agent intégrés
sur les modèles OpenAI s'exécutent par défaut via le runtime app-server Codex natif ;
l'authentification directe par clé API OpenAI reste disponible pour les surfaces OpenAI non-agent,
comme les images, les embeddings, la parole et le temps réel.
- **Modèles d'agent** - modèles `openai/*` via le runtime Codex ; connectez-vous avec
l'authentification Codex pour utiliser un abonnement ChatGPT/Codex, ou configurez une sauvegarde
par clé API OpenAI compatible avec Codex lorsque vous voulez intentionnellement une authentification
par clé API.
- **API OpenAI non-agent** - accès direct à OpenAI Platform avec facturation à l'usage
via `OPENAI_API_KEY` ou l'onboarding par clé API OpenAI.
- **Configuration héritée** - les références de modèles Codex héritées sont réparées par
`openclaw doctor --fix` vers `openai/*` avec le runtime Codex.
OpenAI prend explicitement en charge l'utilisation OAuth par abonnement dans des outils et workflows externes comme OpenClaw.
Le provider, le modèle, le runtime et le canal sont des couches distinctes. Si ces libellés
sont mélangés, lisez [Runtimes d'agent](/fr/concepts/agent-runtimes) avant
de modifier la configuration.
## Choix rapide
| Objectif | Utiliser | Notes |
| ---------------------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------------------- |
| Abonnement ChatGPT/Codex avec runtime Codex natif | `openai/gpt-5.5` | Configuration d'agent OpenAI par défaut. Connectez-vous avec l'authentification Codex. |
| Aperçu limité de GPT-5.6 | `openai/gpt-5.6-sol`, `-terra`, ou `-luna` | Nécessite une organisation API approuvée par OpenAI ou un workspace Codex. |
| Facturation directe par clé API pour les modèles d'agent | `openai/gpt-5.5` avec un profil de clé API compatible Codex | Utilisez `auth.order.openai` pour placer la sauvegarde après l'authentification par abonnement. |
| Facturation directe par clé API via OpenClaw explicite | `openai/gpt-5.5` avec le runtime provider/modèle `openclaw` | Sélectionnez un profil de clé API `openai` normal. |
| Dernier alias d'API ChatGPT Instant | `openai/chat-latest` | Clé API directe uniquement. Alias mobile pour les expérimentations, pas la valeur par défaut. |
| Authentification par abonnement ChatGPT/Codex via OpenClaw | `openai/gpt-5.5` avec le runtime provider/modèle `openclaw` | Sélectionnez un profil OAuth `openai` pour la route de compatibilité. |
| Génération ou modification d'images | `openai/gpt-image-2` | Fonctionne avec `OPENAI_API_KEY` ou OAuth OpenAI Codex. |
| Images à arrière-plan transparent | `openai/gpt-image-1.5` | Utilisez `outputFormat=png` ou `webp` et `openai.background=transparent`. |
## Carte de nommage
Les noms sont similaires, mais ne sont pas interchangeables :
| Nom affiché | Couche | Signification |
| ---------------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------- |
| `openai` | Préfixe de provider | Route canonique des modèles OpenAI ; les tours d'agent utilisent le runtime Codex. |
| préfixe OpenAI Codex hérité | Préfixe hérité | Ancien espace de noms de modèle/profil. `openclaw doctor --fix` le migre vers `openai`. |
| Plugin `codex` | Plugin | Plugin OpenClaw groupé qui fournit le runtime app-server Codex natif et les contrôles de chat `/codex`. |
| provider/modèle `agentRuntime.id: codex` | Runtime d'agent | Force le harnais app-server Codex natif pour les tours intégrés correspondants. |
| `/codex ...` | Jeu de commandes de chat | Lier/contrôler les threads app-server Codex depuis une conversation. |
| `runtime: "acp", agentId: "codex"` | Route de session ACP | Chemin de secours explicite qui exécute Codex via ACP/acpx. |
Cela signifie qu'une configuration peut intentionnellement contenir des références de modèles `openai/*` tandis que les profils
d'authentification pointent vers des identifiants de clé API ou OAuth ChatGPT/Codex. Utilisez
`auth.order.openai` pour la configuration ; `openclaw doctor --fix` réécrit les références de modèles
Codex héritées, les identifiants de profils d'authentification Codex hérités et
l'ordre d'authentification Codex hérité vers la route OpenAI canonique.
GPT-5.5 est disponible à la fois via l'accès direct par clé API OpenAI Platform et
les routes abonnement/OAuth. Pour un abonnement ChatGPT/Codex avec exécution Codex
native, utilisez `openai/gpt-5.5` ; une configuration de runtime non définie sélectionne maintenant le harnais Codex
pour les tours d'agent OpenAI. Utilisez les profils de clé API OpenAI uniquement lorsque vous voulez
une authentification directe par clé API pour un modèle d'agent OpenAI.
## Aperçu limité de GPT-5.6
OpenClaw reconnaît les trois identifiants publics de modèles GPT-5.6 :
- `openai/gpt-5.6-sol`
- `openai/gpt-5.6-terra`
- `openai/gpt-5.6-luna`
Tous trois exposent le raisonnement `max` dans le catalogue app-server Codex actuel. L'annonce
de lancement d'OpenAI décrit Sol comme le palier phare, Terra comme le palier
équilibré, et Luna comme le palier rapide et moins coûteux. Consultez
[l'annonce de lancement de GPT-5.6](https://openai.com/index/previewing-gpt-5-6-sol/)
et le [guide d'accès à l'aperçu](https://help.openai.com/en/articles/20001325-a-preview-of-gpt-5-6-sol-terra-and-luna).
L'accès est soumis à une liste d'autorisation pendant l'aperçu et peut être accordé séparément pour
l'API et Codex. Un forfait ChatGPT payant seul n'accorde pas l'accès. OpenClaw conserve
`openai/gpt-5.5` comme valeur par défaut ; sélectionner une référence GPT-5.6 sans accès renvoie
l'erreur d'accès amont au lieu de revenir silencieusement en arrière.
Les tours de modèles d'agent OpenAI nécessitent le Plugin app-server Codex groupé. La configuration explicite
du runtime OpenClaw reste disponible comme route de compatibilité à activer volontairement. Lorsqu'OpenClaw est
explicitement sélectionné avec un profil OAuth `openai`, OpenClaw conserve la
référence de modèle publique sous la forme `openai/*` et route en interne via le transport
authentifié par Codex. Exécutez `openclaw doctor --fix` pour réparer les
références de modèles Codex héritées obsolètes, `codex-cli/*`, ou les anciens verrouillages de session de runtime qui ne proviennent pas
d'une configuration de runtime explicite.
## Couverture des fonctionnalités OpenClaw
| Capacité OpenAI | Surface OpenClaw | Statut |
| ------------------------ | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Chat / Responses | Provider de modèle `openai/` | Oui |
| Modèles par abonnement Codex | `openai/` avec OAuth OpenAI | Oui |
| Références de modèles Codex héritées | références de modèles Codex héritées ou `codex-cli/` | Réparées par doctor vers `openai/` |
| Harnais app-server Codex | `openai/` avec runtime omis ou provider/modèle `agentRuntime.id: codex` | Oui |
| Recherche Web côté serveur | Outil OpenAI Responses natif | Oui, lorsque la recherche Web est activée et qu'aucun provider n'est épinglé |
| Images | `image_generate` | Oui |
| Vidéos | `video_generate` | Oui |
| Synthèse vocale | `messages.tts.provider: "openai"` / `tts` | Oui |
| Transcription audio par lot | `tools.media.audio` / compréhension des médias | Oui |
| Transcription audio en streaming | Voice Call `streaming.provider: "openai"` | Oui |
| Voix en temps réel | Voice Call `realtime.provider: "openai"` / Control UI Talk `talk.realtime.provider: "openai"` | Oui (nécessite des crédits OpenAI Platform, pas un abonnement Codex/ChatGPT) |
| Embeddings | provider d'embeddings mémoire | Oui |
La voix en temps réel OpenAI (utilisée par `realtime.provider: "openai"` de Voice Call et
Control UI Talk avec `talk.realtime.provider: "openai"`) passe par
l'**API OpenAI Platform Realtime** publique, facturée sur les crédits OpenAI
Platform plutôt que sur le quota d'abonnement Codex/ChatGPT. Un compte
avec un OAuth OpenAI sain qui exécute sans problème des modèles de chat adossés à Codex
a tout de même besoin d'un profil d'authentification par clé API OpenAI ou d'une clé API Platform avec une facturation
Platform approvisionnée pour la voix en temps réel.
Correctif : rechargez les crédits Platform sur
[platform.openai.com/account/billing](https://platform.openai.com/account/billing)
pour l'organisation qui porte vos identifiants temps réel. La voix en temps réel accepte
le profil d'authentification par clé API `openai` créé par `openclaw onboard --auth-choice openai-api-key`,
une clé Platform `OPENAI_API_KEY` configurée via `talk.realtime.providers.openai.apiKey`
pour Control UI Talk, `plugins.entries.voice-call.config.realtime.providers.openai.apiKey`
pour Voice Call, ou la variable d'environnement `OPENAI_API_KEY`. Les profils OAuth OpenAI
peuvent toujours exécuter des modèles de chat `openai/*` adossés à Codex dans la même
installation OpenClaw, mais ils ne configurent pas la voix en temps réel.
## Embeddings mémoire
OpenClaw peut utiliser OpenAI, ou un point de terminaison d'embeddings compatible OpenAI, pour
l'indexation `memory_search` et les embeddings de requête :
```json5
{
agents: {
defaults: {
memorySearch: {
provider: "openai",
model: "text-embedding-3-small",
},
},
},
}
```
Pour les points de terminaison compatibles OpenAI qui exigent des libellés d'embeddings asymétriques, définissez
`queryInputType` et `documentInputType` sous `memorySearch`. OpenClaw les transmet
comme champs de requête `input_type` propres au provider : les embeddings de requête utilisent
`queryInputType` ; les fragments de mémoire indexés et l'indexation par lot utilisent
`documentInputType`. Consultez la [référence de configuration de la mémoire](/fr/reference/memory-config#provider-specific-config) pour l'exemple complet.
## Prise en main
Choisissez votre méthode d'authentification préférée et suivez les étapes de configuration.
**Idéal pour :** l'accès direct à l'API et la facturation à l'usage.
Créez ou copiez une clé API depuis le [tableau de bord OpenAI Platform](https://platform.openai.com/api-keys).
```bash
openclaw onboard --auth-choice openai-api-key
```
Ou transmettez la clé directement :
```bash
openclaw onboard --openai-api-key "$OPENAI_API_KEY"
```
```bash
openclaw models list --provider openai
```
### Résumé des routes
| Réf. du modèle | Configuration du runtime | Route | Authentification |
| ---------------------- | -------------------------- | --------------------------- | ---------------- |
| `openai/gpt-5.5` | omise / provider/model `agentRuntime.id: "codex"` | harnais app-server Codex | profil OpenAI compatible Codex |
| `openai/gpt-5.4-mini` | omise / provider/model `agentRuntime.id: "codex"` | harnais app-server Codex | profil OpenAI compatible Codex |
| `openai/gpt-5.5` | provider/model `agentRuntime.id: "openclaw"` | runtime intégré OpenClaw | profil `openai` sélectionné |
Les modèles d’agent `openai/*` utilisent le harnais app-server Codex. Pour utiliser
l’authentification par clé API pour un modèle d’agent, créez un profil de clé API
compatible Codex et ordonnez-le avec `auth.order.openai` ; `OPENAI_API_KEY` reste
le recours direct pour les surfaces d’API OpenAI non-agent. Exécutez
`openclaw doctor --fix` pour migrer les anciennes entrées d’ordre d’authentification
Codex héritées.
### Exemple de configuration
```json5
{
env: { OPENAI_API_KEY: "example-openai-key-not-real" },
agents: { defaults: { model: { primary: "openai/gpt-5.5" } } },
}
```
Pour essayer le modèle Instant actuel de ChatGPT depuis l’API OpenAI, définissez le modèle
sur `openai/chat-latest` :
```json5
{
env: { OPENAI_API_KEY: "example-openai-key-not-real" },
agents: { defaults: { model: { primary: "openai/chat-latest" } } },
}
```
`chat-latest` est un alias mouvant. OpenAI le documente comme le dernier modèle Instant
utilisé dans ChatGPT et recommande `gpt-5.5` pour l’usage de l’API en production ; conservez donc
`openai/gpt-5.5` comme valeur par défaut stable, sauf si vous voulez explicitement ce
comportement d’alias. L’alias n’accepte actuellement que la verbosité de texte `medium`, donc
OpenClaw normalise les substitutions de verbosité de texte OpenAI incompatibles pour ce
modèle.
OpenClaw n’expose **pas** `gpt-5.3-codex-spark` sur la route directe par clé API OpenAI. Il est disponible uniquement via les entrées de catalogue d’abonnement Codex lorsque votre compte connecté l’expose.
**Idéal pour :** utiliser votre abonnement ChatGPT/Codex avec l’exécution app-server native Codex au lieu d’une clé API séparée. Le cloud Codex nécessite une connexion ChatGPT.
```bash
openclaw onboard --auth-choice openai
```
Ou exécutez OAuth directement :
```bash
openclaw models auth login --provider openai
```
Pour les configurations sans interface ou hostiles aux callbacks, ajoutez `--device-code` pour vous connecter avec un flux de code d’appareil ChatGPT au lieu du callback navigateur localhost :
```bash
openclaw models auth login --provider openai --device-code
```
```bash
openclaw config set agents.defaults.model.primary openai/gpt-5.5
```
Aucune configuration du runtime n’est requise pour le chemin par défaut. Les tours d’agent OpenAI
sélectionnent automatiquement le runtime app-server natif Codex, et OpenClaw
installe ou répare le Plugin Codex groupé lorsque cette route est choisie.
```bash
openclaw models list --provider openai
```
Une fois le gateway en cours d’exécution, envoyez `/codex status` ou `/codex models`
dans le chat pour vérifier le runtime app-server natif.
### Résumé des routes
| Réf. du modèle | Configuration du runtime | Route | Authentification |
|-----------|----------------|-------|------|
| `openai/gpt-5.5` | omise / provider/model `agentRuntime.id: "codex"` | Harnais app-server Codex natif | Connexion Codex ou profil d’authentification `openai` ordonné |
| `openai/gpt-5.5` | provider/model `agentRuntime.id: "openclaw"` | Runtime intégré OpenClaw avec transport interne d’authentification Codex | Profil OAuth `openai` sélectionné |
| Réf. GPT-5.5 Codex héritée | réparée par doctor | Route héritée réécrite vers `openai/gpt-5.5` | Profil OAuth OpenAI migré |
| `codex-cli/gpt-5.5` | réparée par doctor | Route CLI héritée réécrite vers `openai/gpt-5.5` | Authentification app-server Codex |
Préférez `openai/gpt-5.5` pour les nouvelles configurations d’agent adossées à un abonnement. Les anciennes
réfs GPT Codex héritées sont des routes OpenClaw héritées, pas le chemin du runtime Codex
natif ; exécutez `openclaw doctor --fix` lorsque vous voulez les migrer vers les réfs
canoniques `openai/*`. `gpt-5.3-codex-spark` reste limité aux comptes dont le
catalogue d’abonnement Codex annonce ce modèle ; les réfs par clé API OpenAI directe et
Azure pour celui-ci restent supprimées.
Le préfixe de modèle Codex hérité est une configuration héritée réparée par doctor. Pour
la configuration courante abonnement plus runtime natif, connectez-vous avec l’authentification Codex
mais conservez la réf. de modèle `openai/gpt-5.5`. Les nouvelles configurations doivent placer l’ordre
d’authentification des agents OpenAI sous `auth.order.openai` ; doctor migre les anciennes
entrées d’ordre d’authentification Codex héritées.
### Exemple de configuration
```json5
{
plugins: { entries: { codex: { enabled: true } } },
agents: {
defaults: {
model: { primary: "openai/gpt-5.5" },
},
},
}
```
Avec une clé API de secours, conservez le modèle sur `openai/gpt-5.5` et placez
l’ordre d’authentification sous `openai`. OpenClaw essaiera d’abord l’abonnement, puis
la clé API, tout en restant sur le harnais Codex :
```json5
{
plugins: { entries: { codex: { enabled: true } } },
agents: {
defaults: {
model: { primary: "openai/gpt-5.5" },
},
},
auth: {
order: {
openai: [
"openai:user@example.com",
"openai:api-key-backup",
],
},
},
}
```
L’onboarding n’importe plus de matériel OAuth depuis `~/.codex`. Connectez-vous avec OAuth dans le navigateur (par défaut) ou avec le flux de code d’appareil ci-dessus — OpenClaw gère les identifiants résultants dans son propre magasin d’authentification d’agent.
### Vérifier et récupérer le routage OAuth Codex
Utilisez ces commandes pour voir quels modèle, runtime et route d’authentification votre agent
par défaut utilise :
```bash
openclaw models status
openclaw models auth list --provider openai
openclaw config get agents.defaults.model --json
openclaw config get models.providers.openai.agentRuntime --json
```
Pour un agent spécifique, ajoutez `--agent ` :
```bash
openclaw models status --agent
openclaw models auth list --agent --provider openai
```
Si une ancienne configuration contient encore des réfs GPT Codex héritées ou un ancien verrou
de session de runtime OpenAI sans configuration explicite du runtime, réparez-la :
```bash
openclaw doctor --fix
openclaw config validate
```
Si `models auth list --provider openai` n’affiche aucun profil utilisable, connectez-vous
à nouveau :
```bash
openclaw models auth login --provider openai
openclaw models status --probe --probe-provider openai
```
Utilisez `--profile-id` lorsque vous voulez plusieurs connexions OAuth Codex dans le même
agent et souhaitez ensuite les contrôler via l’ordre d’authentification ou `/model ...@` :
```bash
openclaw models auth login --provider openai --profile-id openai:ritsuko
openclaw models auth login --provider openai --profile-id openai:lain
```
`openai/*` est la route de modèle pour les tours d’agent OpenAI via Codex. Exécutez
`openclaw doctor --fix` pour migrer les anciens identifiants de profil avec préfixe OpenAI Codex hérité et les
entrées d’ordre avant de vous appuyer sur l’ordre des profils.
### Indicateur d’état
Le chat `/status` affiche le runtime de modèle actif pour la session actuelle.
Le harnais app-server Codex groupé apparaît comme `Runtime: OpenAI Codex` pour
les tours de modèle d’agent OpenAI. Les anciens verrous de session de runtime OpenAI sont réparés vers Codex sauf si
la configuration épingle explicitement OpenClaw.
### Avertissement de doctor
Si des réfs de modèle Codex héritées ou d’anciens verrous de runtime OpenAI subsistent dans la configuration ou
l’état de session, `openclaw doctor --fix` les réécrit vers `openai/*` avec le
runtime Codex, sauf si OpenClaw est explicitement configuré.
### Limite de fenêtre de contexte
OpenClaw traite les métadonnées de modèle et la limite de contexte du runtime comme des valeurs séparées.
Pour `openai/gpt-5.5` via le catalogue OAuth Codex :
- `contextWindow` natif : `1000000`
- Limite `contextTokens` par défaut du runtime : `272000`
La limite par défaut plus petite offre en pratique de meilleures caractéristiques de latence et de qualité. Remplacez-la avec `contextTokens` :
```json5
{
models: {
providers: {
openai: {
models: [{ id: "gpt-5.5", contextTokens: 160000 }],
},
},
},
}
```
Utilisez `contextWindow` pour déclarer les métadonnées natives du modèle. Utilisez `contextTokens` pour limiter le budget de contexte du runtime.
### Récupération du catalogue
OpenClaw utilise les métadonnées de catalogue Codex en amont pour `gpt-5.5` lorsqu’elles sont
présentes. Si la découverte Codex en direct omet la ligne `gpt-5.5` alors que
le compte est authentifié, OpenClaw synthétise cette ligne de modèle OAuth afin que
les exécutions cron, sous-agent et modèle par défaut configuré n’échouent pas avec
`Unknown model`.
## Authentification app-server Codex native
Le harnais app-server Codex natif utilise des réfs de modèle `openai/*` plus une configuration de
runtime omise ou provider/model `agentRuntime.id: "codex"`, mais son authentification reste
basée sur le compte. OpenClaw sélectionne l’authentification dans cet ordre :
1. Profils d’authentification OpenAI ordonnés pour l’agent, de préférence sous
`auth.order.openai`. Exécutez `openclaw doctor --fix` pour migrer les anciens
identifiants de profil d’authentification Codex hérités et l’ordre d’authentification Codex hérité.
2. Le compte existant de l’app-server, comme une connexion ChatGPT locale de Codex CLI.
3. Pour les lancements app-server stdio locaux uniquement, `CODEX_API_KEY`, puis
`OPENAI_API_KEY`, lorsque l’app-server ne signale aucun compte et nécessite toujours
l’authentification OpenAI.
Cela signifie qu’une connexion locale d’abonnement ChatGPT/Codex n’est pas remplacée simplement
parce que le processus Gateway possède aussi `OPENAI_API_KEY` pour les modèles OpenAI directs
ou les embeddings. Le recours à la clé API d’environnement concerne uniquement le chemin local stdio sans compte ; elle
n’est pas envoyée aux connexions app-server WebSocket. Lorsqu’un profil Codex de type abonnement
est sélectionné, OpenClaw conserve également `CODEX_API_KEY` et `OPENAI_API_KEY`
hors du processus enfant app-server stdio lancé et envoie les identifiants sélectionnés
via le RPC de connexion de l’app-server. Lorsque ce profil d’abonnement est bloqué par une
limite d’usage Codex, OpenClaw peut basculer vers le profil de clé API `openai:*` ordonné suivant
sans changer le modèle sélectionné ni sortir du harnais Codex. Une fois l’heure de réinitialisation de l’abonnement
passée, le profil d’abonnement redevient éligible.
## Génération d’images
Le Plugin `openai` groupé enregistre la génération d’images via l’outil `image_generate`.
Il prend en charge à la fois la génération d’images par clé API OpenAI et la génération d’images OAuth
Codex via la même réf. de modèle `openai/gpt-image-2`.
| Capacité | Clé API OpenAI | OAuth Codex |
| ------------------------ | --------------------------------- | ----------------------------------- |
| Réf. du modèle | `openai/gpt-image-2` | `openai/gpt-image-2` |
| Authentification | `OPENAI_API_KEY` | Connexion OAuth OpenAI Codex |
| Transport | API OpenAI Images | Backend Codex Responses |
| Images max. par requête | 4 | 4 |
| Mode édition | Activé (jusqu’à 5 images de référence) | Activé (jusqu’à 5 images de référence) |
| Remplacements de taille | Pris en charge, y compris les tailles 2K/4K | Pris en charge, y compris les tailles 2K/4K |
| Format / résolution | Non transmis à l’API OpenAI Images | Mappé vers une taille prise en charge lorsque c’est sûr |
```json5
{
agents: {
defaults: {
imageGenerationModel: { primary: "openai/gpt-image-2" },
},
},
}
```
Voir [Génération d’images](/fr/tools/image-generation) pour les paramètres d’outil partagés, la sélection du fournisseur et le comportement de basculement.
`gpt-image-2` est la valeur par défaut pour la génération d’images à partir de texte OpenAI et pour la
modification d’images. `gpt-image-1.5`, `gpt-image-1` et `gpt-image-1-mini` restent utilisables comme
remplacements explicites de modèle. Utilisez `openai/gpt-image-1.5` pour une sortie
PNG/WebP à arrière-plan transparent ; l’API `gpt-image-2` actuelle rejette
`background: "transparent"`.
Pour une requête avec arrière-plan transparent, les agents doivent appeler `image_generate` avec
`model: "openai/gpt-image-1.5"`, `outputFormat: "png"` ou `"webp"`, et
`background: "transparent"` ; l’ancienne option de fournisseur `openai.background` est
toujours acceptée. OpenClaw protège également les routes publiques OpenAI et
OAuth OpenAI Codex en réécrivant les requêtes transparentes par défaut `openai/gpt-image-2`
vers `gpt-image-1.5` ; Azure et les points de terminaison personnalisés compatibles OpenAI conservent
leurs noms de déploiement/modèle configurés.
Le même réglage est exposé pour les exécutions CLI sans interface :
```bash
openclaw infer image generate \
--model openai/gpt-image-1.5 \
--output-format png \
--background transparent \
--prompt "A simple red circle sticker on a transparent background" \
--json
```
Utilisez les mêmes indicateurs `--output-format` et `--background` avec
`openclaw infer image edit` lorsque vous partez d’un fichier d’entrée.
`--openai-background` reste disponible comme alias propre à OpenAI.
Utilisez `--quality low|medium|high|auto` lorsque vous devez contrôler la qualité et le coût
d’OpenAI Images. Utilisez `--openai-moderation low|auto` pour transmettre l’indication de modération
propre au fournisseur OpenAI depuis `image generate` ou `image edit`.
Pour les installations ChatGPT/Codex OAuth, conservez la même réf. `openai/gpt-image-2`. Lorsqu’un
profil OAuth `openai` est configuré, OpenClaw résout ce jeton d’accès OAuth stocké
et envoie les requêtes d’image via le backend Codex Responses. Il ne tente pas d’abord
`OPENAI_API_KEY` et ne rebascule pas silencieusement vers une clé API pour cette
requête. Configurez explicitement `models.providers.openai` avec une clé API,
une URL de base personnalisée ou un point de terminaison Azure lorsque vous voulez utiliser à la place
la route directe de l’API OpenAI Images.
Si ce point de terminaison d’image personnalisé se trouve sur un LAN/adresse privée de confiance, définissez aussi
`browser.ssrfPolicy.dangerouslyAllowPrivateNetwork: true` ; OpenClaw garde
les points de terminaison d’image privés/internes compatibles OpenAI bloqués sauf si cette option explicite est
présente.
Générer :
```
/tool image_generate model=openai/gpt-image-2 prompt="A polished launch poster for OpenClaw on macOS" size=3840x2160 count=1
```
Générer un PNG transparent :
```
/tool image_generate model=openai/gpt-image-1.5 prompt="A simple red circle sticker on a transparent background" outputFormat=png background=transparent
```
Modifier :
```
/tool image_generate model=openai/gpt-image-2 prompt="Preserve the object shape, change the material to translucent glass" image=/path/to/reference.png size=1024x1536
```
## Génération vidéo
Le Plugin `openai` intégré enregistre la génération vidéo via l’outil `video_generate`.
| Capacité | Valeur |
| ----------------- | --------------------------------------------------------------------------------- |
| Modèle par défaut | `openai/sora-2` |
| Modes | Texte vers vidéo, image vers vidéo, modification d’une seule vidéo |
| Entrées de référence | 1 image ou 1 vidéo |
| Remplacements de taille | Pris en charge pour texte vers vidéo et image vers vidéo |
| Autres remplacements | `aspectRatio`, `resolution`, `audio`, `watermark` sont ignorés avec un avertissement d’outil |
Les requêtes image vers vidéo OpenAI utilisent `POST /v1/videos` avec une
`input_reference` d’image. Les modifications d’une seule vidéo utilisent `POST /v1/videos/edits` avec la
vidéo téléversée dans le champ `video`.
```json5
{
agents: {
defaults: {
videoGenerationModel: { primary: "openai/sora-2" },
},
},
}
```
Voir [Génération vidéo](/fr/tools/video-generation) pour les paramètres d’outil partagés, la sélection du fournisseur et le comportement de basculement.
## Contribution de prompt GPT-5
OpenClaw ajoute une contribution de prompt GPT-5 partagée pour les exécutions de la famille GPT-5 sur les surfaces de prompt assemblées par OpenClaw. Elle s’applique par identifiant de modèle ; les routes OpenClaw/fournisseur telles que les anciennes références avant réparation (ancienne réf. Codex GPT-5.5), `openrouter/openai/gpt-5.5`, `opencode/gpt-5.5` et d’autres références GPT-5 compatibles reçoivent donc le même calque. Les anciens modèles GPT-4.x ne le reçoivent pas.
Le harnais Codex natif intégré ne reçoit pas ce calque OpenClaw GPT-5 via les instructions développeur du serveur d’application Codex. Codex natif conserve le comportement de base, de modèle et de documentation de projet appartenant à Codex, tandis qu’OpenClaw désactive la personnalité intégrée de Codex pour les fils natifs afin que les fichiers de personnalité de l’espace de travail de l’agent restent l’autorité. OpenClaw ne contribue que le contexte d’exécution, comme la distribution par canal, les outils dynamiques OpenClaw, la délégation ACP, le contexte d’espace de travail et les Skills OpenClaw.
La contribution GPT-5 ajoute un contrat de comportement balisé pour la persistance de persona, la sécurité d’exécution, la discipline des outils, la forme de sortie, les vérifications d’achèvement et la vérification sur les prompts assemblés par OpenClaw correspondants. Le comportement de réponse propre au canal et de message silencieux reste dans le prompt système OpenClaw partagé et la politique de distribution sortante. La couche de style d’interaction amicale est distincte et configurable.
| Valeur | Effet |
| ---------------------- | ------------------------------------------ |
| `"friendly"` (par défaut) | Active la couche de style d’interaction amicale |
| `"on"` | Alias de `"friendly"` |
| `"off"` | Désactive uniquement la couche de style amical |
```json5
{
agents: {
defaults: {
promptOverlays: {
gpt5: { personality: "friendly" },
},
},
},
}
```
```bash
openclaw config set agents.defaults.promptOverlays.gpt5.personality off
```
Les valeurs sont insensibles à la casse à l’exécution ; `"Off"` et `"off"` désactivent donc toutes deux la couche de style amical.
L’ancien `plugins.entries.openai.config.personality` est toujours lu comme solution de repli de compatibilité lorsque le réglage partagé `agents.defaults.promptOverlays.gpt5.personality` n’est pas défini.
## Voix et parole
Le Plugin `openai` intégré enregistre la synthèse vocale pour la surface `messages.tts`.
| Réglage | Chemin de configuration | Valeur par défaut |
|---------|------------|---------|
| Modèle | `messages.tts.providers.openai.model` | `gpt-4o-mini-tts` |
| Voix | `messages.tts.providers.openai.speakerVoice` | `coral` |
| Vitesse | `messages.tts.providers.openai.speed` | (non défini) |
| Instructions | `messages.tts.providers.openai.instructions` | (non défini, `gpt-4o-mini-tts` uniquement) |
| Format | `messages.tts.providers.openai.responseFormat` | `opus` pour les notes vocales, `mp3` pour les fichiers |
| Clé API | `messages.tts.providers.openai.apiKey` | Se rabat sur `OPENAI_API_KEY` |
| URL de base | `messages.tts.providers.openai.baseUrl` | `https://api.openai.com/v1` |
| Corps supplémentaire | `messages.tts.providers.openai.extraBody` / `extra_body` | (non défini) |
Modèles disponibles : `gpt-4o-mini-tts`, `tts-1`, `tts-1-hd`. Voix disponibles : `alloy`, `ash`, `ballad`, `cedar`, `coral`, `echo`, `fable`, `juniper`, `marin`, `onyx`, `nova`, `sage`, `shimmer`, `verse`.
`extraBody` est fusionné dans le JSON de requête `/audio/speech` après les champs générés par OpenClaw ; utilisez-le donc pour les points de terminaison compatibles OpenAI qui nécessitent des clés supplémentaires comme `lang`. Les clés de prototype sont ignorées.
```json5
{
messages: {
tts: {
providers: {
openai: { model: "gpt-4o-mini-tts", speakerVoice: "coral" },
},
},
},
}
```
Définissez `OPENAI_TTS_BASE_URL` pour remplacer l’URL de base TTS sans affecter le point de terminaison de l’API de chat. OpenAI TTS et la voix Realtime sont tous deux configurés via une clé API OpenAI Platform ; les installations uniquement OAuth peuvent toujours utiliser les modèles de chat adossés à Codex, mais pas le retour vocal en direct OpenAI.
Le Plugin `openai` intégré enregistre la transcription vocale par lots via
la surface de transcription de compréhension multimédia d’OpenClaw.
- Modèle par défaut : `gpt-4o-transcribe`
- Point de terminaison : REST OpenAI `/v1/audio/transcriptions`
- Chemin d’entrée : téléversement de fichier audio multipart
- Pris en charge par OpenClaw partout où la transcription audio entrante utilise
`tools.media.audio`, y compris les segments de canal vocal Discord et les pièces jointes audio
de canal
Pour forcer OpenAI pour la transcription audio entrante :
```json5
{
tools: {
media: {
audio: {
models: [
{
type: "provider",
provider: "openai",
model: "gpt-4o-transcribe",
},
],
},
},
},
}
```
Les indications de langue et de prompt sont transmises à OpenAI lorsqu’elles sont fournies par la
configuration média audio partagée ou par la requête de transcription par appel.
Le Plugin `openai` intégré enregistre la transcription en temps réel pour le Plugin Voice Call.
| Réglage | Chemin de configuration | Valeur par défaut |
|---------|------------|---------|
| Modèle | `plugins.entries.voice-call.config.streaming.providers.openai.model` | `gpt-4o-transcribe` |
| Langue | `...openai.language` | (non défini) |
| Prompt | `...openai.prompt` | (non défini) |
| Durée de silence | `...openai.silenceDurationMs` | `800` |
| Seuil VAD | `...openai.vadThreshold` | `0.5` |
| Authentification | `...openai.apiKey`, `OPENAI_API_KEY` ou OAuth `openai` | Les clés API se connectent directement ; OAuth émet un secret client de transcription Realtime |
Utilise une connexion WebSocket vers `wss://api.openai.com/v1/realtime` avec de l’audio G.711 u-law (`g711_ulaw` / `audio/pcmu`). Lorsque seul OAuth `openai` est configuré, le Gateway émet un secret client éphémère de transcription Realtime avant d’ouvrir le WebSocket. Ce fournisseur de streaming est destiné au chemin de transcription en temps réel de Voice Call ; la voix Discord enregistre actuellement de courts segments et utilise plutôt le chemin de transcription par lots `tools.media.audio`.
Le Plugin `openai` intégré enregistre la voix en temps réel pour le Plugin Voice Call.
| Paramètre | Chemin de configuration | Valeur par défaut |
|---------|------------|---------|
| Modèle | `plugins.entries.voice-call.config.realtime.providers.openai.model` | `gpt-realtime-2` |
| Voix | `...openai.voice` | `alloy` |
| Température (pont de déploiement Azure) | `...openai.temperature` | `0.8` |
| Seuil VAD | `...openai.vadThreshold` | `0.5` |
| Durée du silence | `...openai.silenceDurationMs` | `500` |
| Remplissage du préfixe | `...openai.prefixPaddingMs` | `300` |
| Effort de raisonnement | `...openai.reasoningEffort` | (non défini) |
| Authentification | profil d’authentification par clé API `openai`, `...openai.apiKey` ou `OPENAI_API_KEY` | Clé API OpenAI Platform requise ; OAuth OpenAI ne configure pas la voix Realtime |
Voix Realtime intégrées disponibles pour `gpt-realtime-2` : `alloy`, `ash`,
`ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, `cedar`.
OpenAI recommande `marin` et `cedar` pour la meilleure qualité Realtime. Il
s’agit d’un ensemble distinct des voix de synthèse vocale ci-dessus ; ne supposez pas qu’une voix TTS
comme `fable`, `nova` ou `onyx` est valide pour les sessions Realtime.
Les ponts OpenAI realtime du backend utilisent la forme de session WebSocket Realtime GA, qui n’accepte pas `session.temperature`. Les déploiements Azure OpenAI restent disponibles via `azureEndpoint` et `azureDeployment` et conservent la forme de session compatible avec les déploiements. Prend en charge les appels d’outils bidirectionnels et l’audio G.711 u-law.
La voix Realtime est sélectionnée à la création de la session. OpenAI permet de modifier la plupart
des champs de session ultérieurement, mais la voix ne peut pas être changée une fois que le
modèle a émis de l’audio dans cette session. OpenClaw expose actuellement les
identifiants de voix Realtime intégrées sous forme de chaînes.
Control UI Talk utilise des sessions OpenAI browser realtime avec un secret client
éphémère émis par le Gateway et un échange SDP WebRTC direct du navigateur avec
l’API OpenAI Realtime. Le Gateway émet ce secret client avec le profil
d’authentification par clé API `openai` sélectionné ou la clé API OpenAI Platform configurée. Le relais Gateway
et les ponts WebSocket realtime du backend Voice Call utilisent le même
chemin d’authentification par clé API uniquement pour les points de terminaison OpenAI natifs. La vérification live
par les mainteneurs est disponible avec
`OPENAI_API_KEY=... GEMINI_API_KEY=... node --import tsx scripts/dev/realtime-talk-live-smoke.ts` ;
les segments OpenAI vérifient à la fois le pont WebSocket du backend et l’échange
SDP WebRTC du navigateur sans journaliser de secrets.
## Points de terminaison Azure OpenAI
Le fournisseur `openai` intégré peut cibler une ressource Azure OpenAI pour la génération
d’images en remplaçant l’URL de base. Sur le chemin de génération d’images, OpenClaw
détecte les noms d’hôtes Azure dans `models.providers.openai.baseUrl` et bascule
automatiquement vers la forme de requête d’Azure.
La voix Realtime utilise un chemin de configuration séparé
(`plugins.entries.voice-call.config.realtime.providers.openai.azureEndpoint`)
et n’est pas affectée par `models.providers.openai.baseUrl`. Consultez l’accordéon **Voix
Realtime** sous [Voix et parole](#voice-and-speech) pour ses paramètres Azure.
Utilisez Azure OpenAI lorsque :
- Vous disposez déjà d’un abonnement, d’un quota ou d’un accord d’entreprise Azure OpenAI
- Vous avez besoin de résidence régionale des données ou de contrôles de conformité fournis par Azure
- Vous souhaitez conserver le trafic à l’intérieur d’un tenant Azure existant
### Configuration
Pour la génération d’images Azure via le fournisseur `openai` intégré, pointez
`models.providers.openai.baseUrl` vers votre ressource Azure et définissez `apiKey` sur
la clé Azure OpenAI (et non une clé OpenAI Platform) :
```json5
{
models: {
providers: {
openai: {
baseUrl: "https://.openai.azure.com",
apiKey: "",
},
},
},
}
```
OpenClaw reconnaît ces suffixes d’hôte Azure pour la route de génération d’images
Azure :
- `*.openai.azure.com`
- `*.services.ai.azure.com`
- `*.cognitiveservices.azure.com`
Pour les requêtes de génération d’images sur un hôte Azure reconnu, OpenClaw :
- Envoie l’en-tête `api-key` au lieu de `Authorization: Bearer`
- Utilise des chemins limités au déploiement (`/openai/deployments/{deployment}/...`)
- Ajoute `?api-version=...` à chaque requête
- Utilise un délai d’expiration par défaut de 600 s pour les appels de génération d’images Azure.
Les valeurs `timeoutMs` par appel remplacent toujours cette valeur par défaut.
Les autres URL de base (OpenAI public, proxys compatibles OpenAI) conservent la forme
standard des requêtes d’image OpenAI.
Le routage Azure pour le chemin de génération d’images du fournisseur `openai` nécessite
OpenClaw 2026.4.22 ou une version ultérieure. Les versions antérieures traitent toute
valeur `openai.baseUrl` personnalisée comme le point de terminaison OpenAI public et échoueront avec les
déploiements d’images Azure.
### Version de l’API
Définissez `AZURE_OPENAI_API_VERSION` pour épingler une version Azure preview ou GA spécifique
pour le chemin de génération d’images Azure :
```bash
export AZURE_OPENAI_API_VERSION="2024-12-01-preview"
```
La valeur par défaut est `2024-12-01-preview` lorsque la variable n’est pas définie.
### Les noms de modèle sont des noms de déploiement
Azure OpenAI associe les modèles à des déploiements. Pour les requêtes de génération d’images Azure
acheminées via le fournisseur `openai` intégré, le champ `model` dans OpenClaw
doit être le **nom de déploiement Azure** que vous avez configuré dans le portail Azure, et non
l’identifiant public du modèle OpenAI.
Si vous créez un déploiement nommé `gpt-image-2-prod` qui sert `gpt-image-2` :
```
/tool image_generate model=openai/gpt-image-2-prod prompt="A clean poster" size=1024x1024 count=1
```
La même règle de nom de déploiement s’applique aux appels de génération d’images acheminés via
le fournisseur `openai` intégré.
### Disponibilité régionale
La génération d’images Azure n’est actuellement disponible que dans un sous-ensemble de régions
(par exemple `eastus2`, `swedencentral`, `polandcentral`, `westus3`,
`uaenorth`). Consultez la liste actuelle des régions de Microsoft avant de créer un
déploiement, et confirmez que le modèle spécifique est proposé dans votre région.
### Différences de paramètres
Azure OpenAI et OpenAI public n’acceptent pas toujours les mêmes paramètres d’image.
Azure peut rejeter des options autorisées par OpenAI public (par exemple certaines
valeurs `background` sur `gpt-image-2`) ou ne les exposer que sur des versions de modèle
spécifiques. Ces différences viennent d’Azure et du modèle sous-jacent, et non
d’OpenClaw. Si une requête Azure échoue avec une erreur de validation, vérifiez l’ensemble
de paramètres pris en charge par votre déploiement et votre version d’API spécifiques dans le
portail Azure.
Azure OpenAI utilise le transport natif et le comportement de compatibilité, mais ne reçoit pas
les en-têtes d’attribution masqués d’OpenClaw — consultez l’accordéon **Routes natives vs compatibles OpenAI**
sous [Configuration avancée](#advanced-configuration).
Pour le trafic de chat ou Responses sur Azure (au-delà de la génération d’images), utilisez le
flux d’intégration ou une configuration de fournisseur Azure dédiée — `openai.baseUrl` seul
n’adopte pas la forme d’API/d’authentification Azure. Un fournisseur
`azure-openai-responses/*` séparé existe ; consultez l’accordéon Compaction côté serveur ci-dessous.
## Configuration avancée
OpenClaw utilise WebSocket en priorité avec repli SSE (`"auto"`) pour `openai/*`.
En mode `"auto"`, OpenClaw :
- Retente un premier échec WebSocket avant de se replier sur SSE
- Après un échec, marque WebSocket comme dégradé pendant environ 60 secondes et utilise SSE pendant la période de refroidissement
- Attache des en-têtes stables d’identité de session et de tour pour les nouvelles tentatives et les reconnexions
- Normalise les compteurs d’utilisation (`input_tokens` / `prompt_tokens`) entre les variantes de transport
| Valeur | Comportement |
|-------|----------|
| `"auto"` (par défaut) | WebSocket d’abord, repli SSE |
| `"sse"` | Forcer SSE uniquement |
| `"websocket"` | Forcer WebSocket uniquement |
```json5
{
agents: {
defaults: {
models: {
"openai/gpt-5.5": {
params: { transport: "auto" },
},
},
},
},
}
```
Documentation OpenAI associée :
- [API Realtime avec WebSocket](https://platform.openai.com/docs/guides/realtime-websocket)
- [Réponses API en streaming (SSE)](https://platform.openai.com/docs/guides/streaming-responses)
OpenClaw expose un commutateur de mode rapide partagé pour `openai/*` :
- **Chat/UI :** `/fast status|auto|on|off`
- **Configuration :** `agents.defaults.models["/"].params.fastMode`
Lorsqu’il est activé, OpenClaw mappe le mode rapide au traitement prioritaire d’OpenAI (`service_tier = "priority"`). Les valeurs `service_tier` existantes sont préservées, et le mode rapide ne réécrit pas `reasoning` ni `text.verbosity`. `fastMode: "auto"` lance les nouveaux appels de modèle en mode rapide jusqu’au seuil automatique, puis lance les appels ultérieurs de nouvelle tentative, de repli, de résultat d’outil ou de continuation sans mode rapide. Le seuil par défaut est de 60 secondes ; définissez `params.fastAutoOnSeconds` sur le modèle actif pour le modifier.
```json5
{
agents: {
defaults: {
models: {
"openai/gpt-5.5": { params: { fastMode: "auto", fastAutoOnSeconds: 30 } },
},
},
},
}
```
Les remplacements de session priment sur la configuration. Effacer le remplacement de session dans l’interface Sessions ramène la session à la valeur par défaut configurée.
L’API d’OpenAI expose le traitement prioritaire via `service_tier`. Définissez-le par modèle dans OpenClaw :
```json5
{
agents: {
defaults: {
models: {
"openai/gpt-5.5": { params: { serviceTier: "priority" } },
},
},
},
}
```
Valeurs prises en charge : `auto`, `default`, `flex`, `priority`.
`serviceTier` est transmis uniquement aux points de terminaison OpenAI natifs (`api.openai.com`) et aux points de terminaison Codex natifs (`chatgpt.com/backend-api`). Si vous routez l’un ou l’autre fournisseur via un proxy, OpenClaw laisse `service_tier` inchangé.
Pour les modèles OpenAI Responses directs (`openai/*` sur `api.openai.com`), l’enveloppe de flux OpenClaw du Plugin OpenAI active automatiquement la Compaction côté serveur :
- Force `store: true` (sauf si la compatibilité du modèle définit `supportsStore: false`)
- Injecte `context_management: [{ type: "compaction", compact_threshold: ... }]`
- `compact_threshold` par défaut : 70 % de `contextWindow` (ou `80000` lorsqu’indisponible)
Cela s’applique au chemin d’exécution OpenClaw intégré et aux hooks de fournisseur OpenAI utilisés par les exécutions embarquées. Le harnais de serveur d’application Codex natif gère son propre contexte via Codex et est configuré par la route d’agent par défaut d’OpenAI ou par la stratégie d’exécution fournisseur/modèle.
Utile pour les points de terminaison compatibles comme Azure OpenAI Responses :
```json5
{
agents: {
defaults: {
models: {
"azure-openai-responses/gpt-5.5": {
params: { responsesServerCompaction: true },
},
},
},
},
}
```
```json5
{
agents: {
defaults: {
models: {
"openai/gpt-5.5": {
params: {
responsesServerCompaction: true,
responsesCompactThreshold: 120000,
},
},
},
},
},
}
```
```json5
{
agents: {
defaults: {
models: {
"openai/gpt-5.5": {
params: { responsesServerCompaction: false },
},
},
},
},
}
```
`responsesServerCompaction` contrôle uniquement l’injection de `context_management`. Les modèles OpenAI Responses directs forcent toujours `store: true`, sauf si la compatibilité définit `supportsStore: false`.
Pour les exécutions de la famille GPT-5 sur `openai/*`, OpenClaw peut utiliser un contrat d’exécution intégré plus strict :
```json5
{
agents: {
defaults: {
embeddedAgent: { executionContract: "strict-agentic" },
},
},
}
```
Avec `strict-agentic`, OpenClaw :
- Active automatiquement `update_plan` pour les travaux substantiels
- Réessaie les tours structurellement vides ou uniquement basés sur le raisonnement avec une continuation à réponse visible
- Utilise des événements de plan explicites du harnais lorsque le harnais sélectionné les fournit
OpenClaw ne classe pas la prose de l’assistant pour décider si un tour est un plan, une mise à jour de progression ou une réponse finale.
Limité aux exécutions de la famille GPT-5 d’OpenAI et de Codex uniquement. Les autres fournisseurs et les familles de modèles plus anciennes conservent le comportement par défaut.
OpenClaw traite les points de terminaison directs OpenAI, Codex et Azure OpenAI différemment des proxys `/v1` génériques compatibles OpenAI :
**Routes natives** (`openai/*`, Azure OpenAI) :
- Conservent `reasoning: { effort: "none" }` uniquement pour les modèles qui prennent en charge l’effort OpenAI `none`
- Omettent le raisonnement désactivé pour les modèles ou proxys qui rejettent `reasoning.effort: "none"`
- Utilisent par défaut le mode strict pour les schémas d’outils
- Ajoutent des en-têtes d’attribution masqués uniquement sur les hôtes natifs vérifiés
- Conservent la mise en forme des requêtes propre à OpenAI (`service_tier`, `store`, compatibilité du raisonnement, indications de cache d’invite)
**Routes proxy/compatibles :**
- Utilisent un comportement de compatibilité plus souple
- Retirent Completions `store` des charges utiles `openai-completions` non natives
- Acceptent le JSON de transmission avancée `params.extra_body`/`params.extraBody` pour les proxys Completions compatibles OpenAI
- Acceptent `params.chat_template_kwargs` pour les proxys Completions compatibles OpenAI tels que vLLM
- Ne forcent pas les schémas d’outils stricts ni les en-têtes réservés aux routes natives
Azure OpenAI utilise le transport natif et le comportement de compatibilité, mais ne reçoit pas les en-têtes d’attribution masqués.
## Connexe
Choisir les fournisseurs, les références de modèles et le comportement de basculement.
Paramètres partagés de l’outil d’image et sélection du fournisseur.
Paramètres partagés de l’outil vidéo et sélection du fournisseur.
Détails d’authentification et règles de réutilisation des identifiants.