> ## Documentation Index > Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt > Use this file to discover all available pages before exploring further. # Erreurs > Les enveloppes d'erreur par surface, les codes FlexInference et la normalisation des erreurs des fournisseurs. Les erreurs utilisent l'enveloppe du point de terminaison que vous appelez. `/v1/responses` et `/v1/chat/completions` renvoient des erreurs au format OpenAI. `/v1/messages` renvoie des erreurs au format Anthropic. `/v1/interactions` renvoie des erreurs au format Google. Les erreurs FlexInference et les erreurs des fournisseurs en amont suivent la même règle, de sorte que chaque point de terminaison a une seule forme d'erreur. Vous rencontrez des erreurs 5xx ou des délais d'attente ? Vérifiez d'abord [status.flexinference.com](https://status.flexinference.com). Il affiche la disponibilité en direct de l'API, du site web, de la documentation et du serveur MCP, ainsi que tout incident en cours. Sur `/v1/responses` et `/v1/chat/completions`, les erreurs utilisent l'enveloppe OpenAI : ```json theme={null} { "error": { "message": "The API key on this request was rejected - either it does not match FlexInference's key format (`flex_live_` followed by 24 hex characters and a 6-hex checksum), or it is well-formed but does not match any key on record. Copy the exact, current key from the FlexInference dashboard under Settings -> API keys, then send it as `Authorization: Bearer `.", "type": "authentication_error", "code": "invalid_api_key", "param": null, "doc_url": "https://docs.flexinference.com/errors#invalid_api_key" } } ``` La même erreur sur `/v1/messages` utilise le format d'Anthropic. Sur `/v1/interactions`, elle utilise le format de Google : ```json theme={null} { "type": "error", "error": { "type": "authentication_error", "message": "..." } } ``` ```json theme={null} { "error": { "code": 401, "message": "...", "status": "UNAUTHENTICATED" } } ``` Le statut HTTP et le message restent les mêmes sur toutes les surfaces ; seul l'encapsuleur change. L'enveloppe OpenAI contient tous les détails. Le `type` utilise les catégories OpenAI (`invalid_request_error`, `authentication_error`, `rate_limit_error`) ainsi que `flexinference_error` pour les erreurs internes et `billing_error` lorsque l'état de facturation suspend les requêtes facturables. Le `code` est la raison lisible par machine. Le `param` nomme le champ incriminé, le cas échéant. Le `doc_url` renvoie à la ligne de ce code ci-dessous, ou est `null` si inconnu. Le format Anthropic contient un `type` Anthropic mappé à partir du statut plus le message. Le format Google contient le `code` numérique, le message et un `status` canonique. Les `code` et `doc_url` spécifiques à FlexInference n'apparaissent que sur l'enveloppe OpenAI. ## Codes FlexInference Ces codes proviennent de FlexInference. Basez-vous sur `error.code` ; `error.message` est rédigé pour les développeurs et inclut la solution si elle existe. Plusieurs erreurs impliquent `start_within`. Pour les valeurs de durée sur les modèles compatibles flex, FlexInference essaie d'abord le niveau flex moins cher. Si flex ne peut pas démarrer dans cette fenêtre, FlexInference envoie la même requête au niveau standard. Le standard est le chemin de secours, pas la première tentative. | Status | Code | Meaning | | ------ | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `401` | `missing_api_key` | Aucun en-tête `Authorization`, ou la valeur n'est pas `Bearer `. Envoyez `Authorization: Bearer `. | | `401` | `invalid_api_key` | La clé ne correspond pas au format de FlexInference (`flex_live_` + 24 caractères hexadécimaux + un checksum de 6 caractères hexadécimaux), ou elle correspond au format mais est inconnue car elle a été révoquée, régénérée ou mal saisie. Copiez la clé actuelle depuis le tableau de bord. | | `429` | `rate_limit_exceeded` | La requête a atteint l'une de ces limites : tentatives d'authentification échouées depuis votre IP client, requêtes depuis une clé ou une IP client, requêtes depuis votre organisation, ou baux de concurrence flex facturables. Le limiteur de concurrence flex facturable est par défaut de 20 requêtes en cours. Attendez le nombre de secondes indiqué dans `Retry-After`, généralement 60s pour le limiteur d'inondation d'authentification et 5s pour les autres limiteurs de requêtes. | | `402` | `payment_required` | Cette organisation a un solde impayé ou aucune méthode de paiement enregistrée, de sorte que les requêtes flex facturables sont suspendues. Le routage gratuit (`default`, `priority`, `auto`) et toutes les requêtes de niveau Anthropic continuent de fonctionner. Ajoutez ou mettez à jour une carte sur la page [Facturation](/fr/billing) du tableau de bord, puis réessayez. C'est le seul code avec `type: billing_error`. | | `413` | `request_too_large` | Le corps de la requête dépasse la limite de 1 000 000 octets de FlexInference, vérifiée à la fois par le `Content-Length` déclaré et les octets réellement diffusés. Les fichiers base64 en ligne volumineux en sont la cause habituelle. Réduisez la charge utile ou pointez vers une URL hébergée à la place. | | `400` | `no_byok_key` | Aucune clé OpenAI n'est configurée pour votre organisation. Ajoutez-en une dans le tableau de bord sous Settings -> API keys. Les clés BYOK sont stockées chiffrées ; si une clé stockée existe mais ne peut pas être déchiffrée, la requête échoue avec `500 internal_error`, et non ce code. Chaque route que vous nommez dans une chaîne `provider` a besoin de sa clé : une clé manquante est une erreur de configuration, pas une défaillance transitoire, elle est donc rejetée avant tout appel en amont et ne passe jamais à la route suivante. | | `400` | `no_gemini_key` | Identique à `no_byok_key`, pour un modèle `gemini-*` : aucune clé Gemini n'est configurée pour votre organisation. Ajoutez-en une dans le tableau de bord. | | `400` | `no_anthropic_key` | Identique à `no_byok_key`, pour un modèle `claude-*` : aucune clé Anthropic n'est configurée pour votre organisation. Ajoutez-en une dans le tableau de bord. | | `400` | `no_bedrock_key` | Identique à `no_byok_key`, pour une route `bedrock` dans la chaîne `provider` : aucune clé Bedrock n'est configurée pour votre organisation. Bedrock sert les modèles `claude-*` via Amazon Bedrock en utilisant votre propre clé ; ajoutez-en une dans le tableau de bord sous Settings -> API keys. Une entrée `bedrock` n'importe où dans la chaîne nécessite la clé, donc une clé manquante est rejetée avant tout appel en amont. | | `400` | `no_vertex_key` | Identique à `no_byok_key`, pour une route `vertex` dans la chaîne `provider` : aucune clé Vertex n'est configurée pour votre organisation. Vertex sert les modèles `gemini-*` via Google Vertex AI en utilisant votre propre clé express (préfixe `AQ.`) ; ajoutez-en une dans le tableau de bord sous Settings -> API keys. Une entrée `vertex` n'importe où dans la chaîne nécessite la clé, donc une clé manquante est rejetée avant tout appel en amont. | | `400` | `missing_model` | Le champ `model` est manquant, vide ou n'est pas une chaîne de caractères. Ajoutez une chaîne non vide, par exemple `"model": "gpt-5.5"`. | | `400` | `missing_start_within` | Le champ `start_within` requis est manquant, et aucune valeur par défaut n'est appliquée. `start_within` définit le temps que vous êtes prêt à attendre pour que la requête démarre. Utilisez `default`, `priority`, `auto`, ou une durée comme `HHh-MMm-SSs`, par exemple `00h-00m-30s` pour attendre jusqu'à trente secondes. | | `400` | `invalid_start_within` | `start_within` n'est pas une chaîne de caractères, ne correspond pas à l'une des quatre formes acceptées, ou se résout en dehors de la fenêtre autorisée de 5 secondes à 600 secondes (10 minutes) pour une durée. Respectez la forme exacte et maintenez les durées entre 5s et 600s. Par exemple, utilisez `"start_within": "00h-00m-30s"` pour une fenêtre de trente secondes, ou `"start_within": "default"` pour ignorer la course flex. | | `400` | `auto_unsupported_for_gemini` | `start_within: "auto"` a été utilisé sur un modèle Gemini. Les niveaux de Gemini sont uniquement `flex`, `standard` et `priority` ; il n'y a pas de `auto` à résoudre. Utilisez `default`, `priority` ou une durée à la place. | | `400` | `flex_unsupported_for_anthropic` | Une durée `start_within` (course flex) a été envoyée à un modèle `claude-*`, mais Anthropic n'a pas de niveau flex contre lequel courir. FlexInference ne sert plus silencieusement le standard pour une course flex inapplicable. Utilisez un niveau `start_within` (`default`, `priority`, `auto`) ou omettez-le. | | `400` | `flex_model_not_capable` | Une durée `start_within` a été envoyée à un modèle OpenAI ou Gemini qui ne figure pas sur la liste blanche flex. Utilisez un niveau `start_within` ou choisissez un modèle compatible flex. | | `400` | `service_tier_not_allowed` | La requête incluait `service_tier`. FlexInference dérive le niveau de `start_within` ; accepter un `service_tier` fourni par l'appelant nécessiterait de l'écraser, donc le routeur rejette le champ. Supprimez `service_tier` et exprimez la même intention via `start_within`. S'applique également sur `/v1/interactions` et `/v1/messages`. | | `400` | `unsupported_parameter` | Un paramètre natif du fournisseur a été envoyé à un fournisseur différent, ou un champ Responses canonique n'a pas de mappage pour le fournisseur cible. Les paramètres natifs de Chat passent sur les modèles OpenAI mais échouent sur les modèles Gemini ou Claude. Les paramètres natifs d'Anthropic passent sur les modèles Claude mais échouent sur les modèles OpenAI ou Gemini, à l'exception des blocs de contenu `document` et `file` avec des sources base64, qui sont traduits pour chaque fournisseur. `cache_control`, les citations et d'autres paramètres natifs du fournisseur échouent toujours entre fournisseurs. Supprimez le champ nommé ou choisissez un modèle dont le fournisseur le possède ; `error.param` nomme exactement lequel. Voir [SDKs](/fr/sdks). | | `400` | `unsupported_generation_config` | Sur `/v1/interactions`, un champ `generation_config.*` non mappé a été défini en ciblant un modèle non-Gemini. Les clés supplémentaires natives de Gemini passent sur les modèles Gemini. Supprimez le champ nommé ou ciblez un modèle Gemini. | | `400` | `unsupported_tool` | Le tableau `tools` contient un outil intégré qui fait que le modèle émet une sortie non textuelle, actuellement `image_generation`. FlexInference ne sert que des sorties textuelles, sur chaque point de terminaison. Supprimez cette entrée d'outil ; les outils de fonction et `web_search` restent pris en charge. | | `400` | `unsupported_value` | Chat Completions `n` a été défini sur une valeur autre que `1`. L'API Responses sous-jacente produit toujours une seule génération, donc `n` doit être `1` ou omis. Par exemple, envoyez `"n": 1` ou omettez `n`. | | `400` | `invalid_json` | Le corps n'est pas un JSON syntaxiquement valide (`JSON.parse` a échoué). Corrigez la syntaxe ; une virgule finale ou une clé non entre guillemets est une cause fréquente. | | `400` | `invalid_body` | Le corps a été analysé comme JSON, mais la valeur de niveau supérieur n'est pas un objet JSON. Les tableaux, chaînes, nombres, booléens et null sont invalides. Enveloppez vos champs dans un seul objet `{...}`. | | `400` | `invalid_stream` | Le champ `stream` doit être un booléen JSON. FlexInference ne forcera pas une valeur non booléenne, y compris la chaîne `"true"`, car cela pourrait choisir le mauvais mode de réponse. Envoyez `stream` comme un vrai booléen, par exemple `"stream": true`, ou omettez-le pour une réponse non diffusée. | | `400` | `invalid_retry` | La valeur `retry` est invalide. `retry` est un objet `{ count, backoff?, jitter? }` où `count` est un entier de 1 à 5 (combien de fois FlexInference ré-interroge le niveau amont en cas de 429 ou 5xx transitoire), `backoff` est `"exponential"` ou `"linear"`, et `jitter` est un booléen. Ce code unique couvre un `count` manquant ou hors plage, une mauvaise valeur `backoff`, un `jitter` non booléen, et toute sous-clé inconnue. Corrigez ou supprimez le champ, par exemple `"retry": {"count": 2}`. `retry` ne ré-interroge le niveau établi qu'avant que la réponse ne soit validée ; il ne réessaie jamais après le premier octet, un échec d'authentification ou un 4xx client. | | `400` | `invalid_provider_chain` | Le tableau `provider` optionnel est malformé : ce n'est pas un tableau, il est vide, contient un nom de route inconnu, un doublon, ou plus de trois entrées. Chaque entrée doit être l'une des suivantes : `google`, `openai`, `anthropic`, `vertex` ou `bedrock` ; l'élément 0 est la route principale et les autres sont la chaîne de secours ordonnée pour le même modèle. Omettez `provider` pour utiliser la route native du modèle, ou corrigez le tableau, par exemple `["google", "vertex"]`. Un seul code couvre toutes les raisons de chaîne malformée, comme `invalid_retry` ; `error.message` nomme la faute spécifique. | | `400` | `provider_model_mismatch` | Une route dans la chaîne `provider` ne peut pas servir le modèle demandé. Chaque route sert une famille de modèles : `openai` sert les modèles GPT et de la série o, `google` et `vertex` servent Gemini, et `anthropic` et `bedrock` servent Claude. Supprimez la route qui ne correspond pas à ce modèle, ou envoyez la requête à un modèle que cette route peut servir, par exemple `["anthropic"]` pour un modèle `claude-*`. | | `400` | `flex_unsupported_on_cloud` | Une durée `start_within` (une course flex) a été envoyée avec une route cloud (`vertex` ou `bedrock`) comme élément 0, mais les routes cloud n'ont pas de niveau flex contre lequel courir. FlexInference ne sert pas silencieusement le niveau par défaut pour une course flex inapplicable. Utilisez un niveau `start_within` (`default`, `priority` ou `auto`) pour exécuter la route cloud comme un simple appel standard, ou placez une route directe compatible flex (`openai` ou `google`) en premier dans `provider`. | | `400` | `bedrock_model_unavailable` | Une route `bedrock` n'a pas d'ID de modèle Amazon Bedrock pour ce slug, la requête est donc rejetée avant tout appel en amont. Aujourd'hui, cela signifie `claude-opus-4-1` (retiré de la route `bedrock` car AWS ne le publie qu'aux États-Unis ; envoyez-le à `anthropic` à la place) ou un texte `claude-*` arbitraire non mappé. Bedrock sert chaque modèle Claude mappé via son profil d'inférence `global.`, de sorte qu'un modèle servi est accessible depuis n'importe quelle région ; la géolocalisation dérivée de la région (`us-*` -> `us.`, `eu-*` -> `eu.`, tout le reste -> `global.`) n'est qu'un fallback dormant pour un futur modèle qui ne publie pas de profil `global.`. Ceci est permanent pour ce slug, non transitoire. Chaque route nommée dans `provider` doit pouvoir servir la requête, donc nommer `bedrock` fait échouer la requête même si une autre route de la chaîne pourrait servir ce modèle. Supprimez `bedrock` de `provider`, ou envoyez le modèle à une route qui le sert. | | `403` | `bedrock_model_access_denied` | Amazon Bedrock a refusé le modèle pour le compte AWS derrière la clé Bedrock de votre organisation, et FlexInference transmet l'explication de Bedrock (`... n'est pas disponible pour ce compte`). Votre clé Bedrock est valide et fonctionne : il s'agit d'une autorisation d'accès par modèle manquante sur le compte AWS, et non d'un problème de clé, donc le remplacement de la clé ne résoudra pas le problème. Pour la plupart des modèles Claude, accordez l'accès au modèle dans la console Amazon Bedrock sous Model access. Les quatre modèles les plus récents (`claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`) nécessitent en outre une configuration de compte unique que l'octroi de la console ne couvre pas - une option d'activation de la rétention des données `provider_data_share` et un accord de modèle, exécutés avec des identifiants AWS d'administrateur ; voir [la configuration des modèles les plus récents](/fr/models). Sinon, envoyez le modèle à la route `anthropic` à la place, ou choisissez un modèle que le compte possède déjà. Il s'agit d'un écart de configuration permanent, c'est pourquoi il s'agit d'un `403` et non d'un `502` réessayable. | | `404` | `unknown_url` | Mauvais chemin. Utilisez `/v1/responses`, `/v1/chat/completions`, `/v1/interactions` ou `/v1/messages`. | | `405` | `method_not_allowed` | Le chemin existe, mais les points de terminaison FlexInference n'acceptent que `POST`. Envoyez une requête `POST` avec un corps JSON. | | `499` | `client_closed_request` | Le client s'est déconnecté avant que FlexInference n'ait fini de répondre, généralement en raison d'un onglet fermé, d'une récupération annulée ou d'un délai d'attente côté client. Ceci n'est pas compté comme une défaillance de service. Si vous n'aviez pas l'intention d'annuler, augmentez le délai d'attente de votre client et laissez la requête se terminer. Une requête flex peut légitimement prendre jusqu'à 10 minutes. | | `500` | `internal_error` | FlexInference a échoué en dehors de la validation des entrées. Réessayez une fois ; si cela persiste, contactez le support avec l'horodatage approximatif et votre organisation. | | `500` | `server_misconfigured` | Une liaison ou un secret requis est absent ou malformé, de sorte que FlexInference ne peut pas authentifier les appelants ou déchiffrer les clés BYOK. Il s'agit d'une erreur de déploiement côté serveur distincte de `internal_error`, et non d'un problème avec votre requête. Réessayez sous peu et contactez le support si cela persiste. | | `502` | `upstream_stream_failed` | Le fournisseur en amont a validé une réponse, puis son flux s'est terminé sans événement de complétion ou a échoué en cours de flux sans erreur de fournisseur à transmettre. Il s'agit d'une défaillance transitoire en amont ou du réseau entre FlexInference et le fournisseur, et non de votre requête. Réessayez une fois. Si cela persiste pour un modèle, le fournisseur ou le modèle peut être dégradé ; essayez un autre modèle, ou définissez une fenêtre `start_within` plus courte afin qu'une tentative lente passe plus tôt à votre niveau standard. Distinct d'un `5xx` en amont que le fournisseur lui-même a renvoyé, qui est remodelé à votre surface avec le message du fournisseur. | | `502` | `upstream_unavailable` | FlexInference n'a pas pu ouvrir une connexion au fournisseur en amont avant qu'une réponse ne soit validée (la connexion a été refusée, ou le DNS, le TLS ou le réseau ont échoué). Il s'agit d'une défaillance en amont ou du réseau, et non de votre requête. Réessayez une fois ; si cela continue d'échouer pour un modèle, le fournisseur peut être en panne, alors essayez un autre modèle. Distinct de `upstream_stream_failed`, où une réponse avait déjà commencé. | | `502` | `upstream_auth_failed` | Le fournisseur en amont a rejeté la clé API que votre organisation lui a associée (HTTP 401 ou 403, avant qu'une réponse ne soit validée). Ce n'est pas votre clé FlexInference qui échoue ; l'identifiant du fournisseur stocké manque d'accès, a été révoqué, a expiré ou est autrement invalide. Demandez à un administrateur d'organisation de mettre à jour la clé du fournisseur associée dans le tableau de bord sous Settings -> API keys, puis réessayez. | | `502` | `all_routes_failed` | Chaque route de la chaîne `provider` a échoué de manière transitoire avant qu'une réponse ne soit validée (chaque tentative en amont a renvoyé un `429`, un `5xx`, une erreur de connexion ou un délai d'attente), il ne restait donc aucune route de secours. Il s'agit d'une condition en amont ou du réseau, et non de votre requête, elle est donc signalée comme `502` même si la chaîne elle-même est épuisée. Réessayez une fois ; les brefs problèmes en amont se résolvent généralement. Si cela persiste, essayez un modèle différent ou réduisez la chaîne aux routes qui sont actuellement saines. | | `503` | `usage_persistence_unavailable` | FlexInference n'a pas pu enregistrer durablement l'utilisation pour une requête facturable. Réessayez une fois que la persistance de l'utilisation est rétablie. | | `504` | `upstream_timeout` | Le fournisseur en amont n'a pas commencé à répondre avant le délai d'attente en amont de FlexInference, la requête a donc été annulée entre FlexInference et le fournisseur. Il s'agit presque toujours d'un ralentissement ou d'une panne transitoire du fournisseur, et non de votre requête, et est signalé comme `504` plutôt que comme une erreur interne. Réessayez une fois ; si cela continue de dépasser le délai d'attente pour un modèle, le fournisseur peut être dégradé, alors essayez un autre modèle, ou pour une durée `start_within`, définissez un délai plus court comme `00h-00m-30s`. | Le tableau `provider` fixe votre route. `google`, `openai` et `anthropic` sont des routes directes ; `vertex` et `bedrock` sont des routes cloud qui servent `gemini-*` et `claude-*` sur Google Vertex AI et Amazon Bedrock respectivement. Une route cloud dont la clé n'est pas configurée renvoie [`no_vertex_key`](/fr/errors#no_vertex_key) ou [`no_bedrock_key`](/fr/errors#no_bedrock_key), le même modèle de clé manquante que [`no_gemini_key`](/fr/errors#no_gemini_key) et [`no_anthropic_key`](/fr/errors#no_anthropic_key) ci-dessus. `upstream_auth_failed` couvre tout identifiant de fournisseur attaché que l'amont rejette, y compris les routes cloud. Voir [provider routing](/fr/models). ## En-têtes de résultat Flex Les réponses `200` réussies incluent les en-têtes de résultat Flex sur chaque point de terminaison, pour les appels en streaming et non-streaming. Les réponses d'erreur utilisent le corps de l'erreur à la place. | Header | Meaning | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `x-flexinference-flex-requested` | `true` lorsque l'appelant a envoyé une durée `start_within` ; `false` lorsque l'appelant a envoyé `default`, `priority` ou `auto`. | | `x-flexinference-flex-applied` | `true` uniquement lorsque le niveau flex a servi la réponse. | | `x-flexinference-flex-reason` | Résultat flex lisible par machine. Voir les valeurs ci-dessous. | | `x-flexinference-provider-surface` | Surface d'exécution du fournisseur. Les valeurs sont `openai.responses`, `openai.chat`, `gemini.interactions` et `anthropic.messages`. Ce n'est pas toujours le point de terminaison de l'appelant. Un appel `/v1/chat/completions` avec un modèle OpenAI rapporte `openai.responses` sauf si un passthrough Chat natif est requis, auquel cas il rapporte `openai.chat`. | Valeurs `x-flexinference-flex-reason` en direct : | Reason | Meaning | | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `not_requested` | La requête a utilisé `default`, `priority` ou `auto`, donc aucune course flex n'a été demandée. | | `flex_committed` | La course flex a été validée. La réponse affiche `service_tier: "flex"` et `x-flexinference-flex-applied: true`. | | `flex_lost_race` | La requête a utilisé une durée sur un modèle compatible flex, mais flex n'a pas démarré dans la fenêtre et la requête est revenue au standard. | Une durée qui ne peut pas exécuter une course flex renvoie `400` (`flex_unsupported_for_anthropic` sur un modèle `claude-*`, `flex_model_not_capable` sur un modèle OpenAI/Gemini non compatible flex) ; les raisons d'en-tête décrivent uniquement les requêtes qui ont exécuté flex ou ne l'ont pas demandé. ## Erreurs des fournisseurs Les erreurs des fournisseurs en amont utilisent la même enveloppe de surface que les erreurs FlexInference. FlexInference conserve le statut et le message du fournisseur, puis les émet dans l'enveloppe du point de terminaison que vous avez appelé. Un `400` du fournisseur pour un mauvais paramètre, un `401` pour une clé de fournisseur invalide, ou une limite de débit `429` sur la tentative standard revient sous cette forme. Vous ne recevez pas le corps brut du fournisseur. Par exemple, si vous appelez `/v1/messages` et qu'une erreur de modèle OpenAI revient au format Anthropic. Les `code` et `doc_url` spécifiques à FlexInference n'apparaissent que sur l'enveloppe OpenAI ; les erreurs des fournisseurs contiennent le message du fournisseur avec le `type` ou le `status` de la surface. Sur la surface OpenAI, basez-vous sur `error.code` pour la gestion spécifique à FlexInference, comme inviter l'utilisateur à ajouter une clé BYOK sur `no_byok_key`. Traitez les codes inconnus comme des erreurs OpenAI ordinaires. ## Gestion des erreurs dans le code Les SDK OpenAI lèvent une exception en cas de réponses non-2xx et attachent le corps analysé. ```python Python theme={null} from openai import APIStatusError try: resp = client.responses.create( model="gpt-5.5", input="hi", extra_body={"start_within": "00h-00m-30s"}, ) except APIStatusError as e: code = (e.body or {}).get("error", {}).get("code") if code == "no_byok_key": print("Add your OpenAI key in the dashboard.") else: raise ``` ```typescript Node theme={null} import OpenAI from "openai"; try { await client.responses.create({ model: "gpt-5.5", input: "hi", start_within: "00h-00m-30s", } as any); } catch (e) { if (e instanceof OpenAI.APIError && e.code === "no_byok_key") { console.log("Add your OpenAI key in the dashboard."); } else { throw e; } } ```