Protocole Compatible OpenAI

Le protocole compatible OpenAI est le standard d’API IA le plus largement supporté dans l’industrie. RouteAPI implémente entièrement la spécification de l’API OpenAI, vous permettant de vous intégrer de manière transparente avec les SDKs, outils et clients OpenAI existants en changeant simplement l’URL de base et la clé API.

Vue d’ensemble du protocole

L’API OpenAI définit un ensemble standardisé d’interfaces REST pour la génération de conversations, les embeddings de texte, le listage des modèles et d’autres capacités. Son principal avantage réside dans son écosystème mature : les SDKs officiels OpenAI, LangChain, LiteLLM, Cursor et divers assistants de codage supportent nativement ce protocole.

Périmètre de compatibilité de RouteAPI :

• Entièrement compatible avec les endpoints OpenAI Chat Completions, Responses, Embeddings et Models
• Authentification cohérente utilisant les en-têtes de requête Authorization: Bearer
• Formats de requête/réponse cohérents, incluant le streaming SSE et les structures d’erreur
• Gamme d’ID de modèles plus large, peut appeler OpenAI, Claude, Gemini, Mistral et d’autres fournisseurs
• Paramètres à valeur zéro explicite préservés, les 0 / false explicitement passés ne sont pas supprimés

Migrer de l’API OpenAI officielle vers RouteAPI ne nécessite que deux modifications de configuration :

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-routeapi-token",        # Basculer vers le Token RouteAPI
    base_url="https://api.routeapi.ai/v1"   # Basculer vers l'URL de base RouteAPI
)

Tout le reste du code reste inchangé.

URL de base

https://api.routeapi.ai/v1

Tous les endpoints compatibles OpenAI utilisent cette URL de base. Si votre client ou SDK nécessite l’URL complète, ajoutez simplement le chemin de l’endpoint, par ex. https://api.routeapi.ai/v1/chat/completions.

Authentification

Identique à l’API OpenAI officielle, utilisant l’en-tête de requête HTTP Authorization :

Authorization: Bearer sk-your-routeapi-token
Content-Type: application/json

Les tokens RouteAPI commencent par sk- et sont générés sur la page API Keys dans la console. Stockez les tokens côté serveur et ne les exposez pas dans les navigateurs, les applications mobiles ou les dépôts publics.

Vue d’ensemble des endpoints supportés

Endpoint	Objectif	Documentation détaillée
/v1/chat/completions	Génération de conversations, supporte le dialogue multi-tours, l’appel d’outils, la sortie structurée	Chat Completions
/v1/responses	Protocole OpenAI Responses, adapté aux agents de codage et aux frameworks d’application de nouvelle génération	Responses
/v1/embeddings	Embeddings vectoriels de texte pour la recherche sémantique, RAG, calcul de similarité	Embeddings
/v1/models	Obtenir la liste des modèles disponibles pour le compte actuel	Ci-dessous sur cette page

Comparaison des cas d’usage

Scénario	Endpoint recommandé	Raison
Chat général, Q&R, résumé, classification	/v1/chat/completions	Écosystème le plus mature, compatibilité la plus large
Agents de codage (Cursor, Claude Code, Copilot)	/v1/responses ou /v1/chat/completions	Dépend du protocole nativement supporté par le client
Dialogue multi-tours, historique de conversation	/v1/chat/completions	Le tableau messages supporte naturellement plusieurs tours
Appel d’outils, function calling	/v1/chat/completions	Structure de définition d’outils et de passage de résultats la plus standard
Recherche sémantique, RAG, récupération de documents	/v1/embeddings	Retourne des représentations vectorielles
Sortie structurée, JSON Schema	/v1/chat/completions ou /v1/responses	Contrôlé via le paramètre response_format

Le choix de l’endpoint spécifique doit prioriser le support natif du client et du SDK. Si le client nécessite explicitement un certain protocole, suivez les exigences du client.

Configuration SDK

SDK Python OpenAI

Installation :

pip install openai

Configurer RouteAPI :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "Veuillez présenter RouteAPI en une phrase"}
    ]
)

print(response.choices[0].message.content)

Seuls les paramètres api_key et base_url doivent être définis ; tout le reste du code est identique à l’API officielle.

SDK Node.js OpenAI

Installation :

npm install openai

Configurer RouteAPI :

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

const response = await client.chat.completions.create({
  model: 'gpt-5.5',
  messages: [
    { role: 'user', content: 'Veuillez présenter RouteAPI en une phrase' }
  ]
});

console.log(response.choices[0].message.content);

LangChain

La classe ChatOpenAI de LangChain supporte un base_url personnalisé :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.5",
    openai_api_key=os.environ["ROUTEAPI_KEY"],
    openai_api_base="https://api.routeapi.ai/v1"
)

response = llm.invoke("Veuillez présenter RouteAPI en une phrase")
print(response.content)

LiteLLM

La fonction completion() de LiteLLM supporte un api_base personnalisé :

import litellm

response = litellm.completion(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Veuillez présenter RouteAPI en une phrase"}],
    api_key=os.environ["ROUTEAPI_KEY"],
    api_base="https://api.routeapi.ai/v1"
)

print(response.choices[0].message.content)

Autres clients compatibles

Tout client, outil ou framework qui supporte l’API OpenAI peut s’intégrer avec RouteAPI via la configuration suivante :

1. Clé API définie sur le Token RouteAPI (commence par sk-)
2. URL de base définie sur https://api.routeapi.ai/v1
3. ID de modèle utiliser les noms de modèles supportés par RouteAPI (requête via /v1/models)

Paramètres de requête principaux

Les principaux endpoints du protocole compatible OpenAI partagent un ensemble de paramètres de base. Voici un tableau de référence rapide pour les paramètres courants ; des explications détaillées sont disponibles dans la documentation dédiée de chaque endpoint.

Paramètres Chat Completions

Paramètre	Type	Requis	Description
model	string	Oui	ID du modèle, doit être disponible pour le compte actuel
messages	array	Oui	Liste de messages de conversation, chaque message contient role et content
stream	boolean	Non	Utiliser la sortie streaming SSE, par défaut false
temperature	number	Non	Température d’échantillonnage, plage de 0 à 2, par défaut 1
top_p	number	Non	Paramètre d’échantillonnage nucleus, plage de 0 à 1
max_tokens	number	Non	Tokens de sortie maximum (ancien nom de paramètre, toujours requis par certains modèles)
max_completion_tokens	number	Non	Tokens de sortie maximum (nouveau nom de paramètre)
tools	array	Non	Liste de définition d’outils pour function calling
tool_choice	string/object	Non	Stratégie de sélection d’outils (auto / required / none / outil spécifique)
response_format	object	Non	Contrainte de format de sortie (mode JSON / JSON Schema)
stream_options	object	Non	Options de streaming supplémentaires, telles que include_usage
stop	string/array	Non	Séquences d’arrêt personnalisées
presence_penalty	number	Non	Pénalité de présence, plage de -2 à 2
frequency_penalty	number	Non	Pénalité de fréquence, plage de -2 à 2
user	string	Non	Identifiant d’utilisateur final pour la détection d’abus

Pour des explications détaillées et plus de paramètres, consultez la documentation Chat Completions.

Paramètres Embeddings

Paramètre	Type	Requis	Description
model	string	Oui	ID du modèle d’embedding
input	string/array	Oui	Texte à embedder, supporte une chaîne unique ou un tableau de chaînes
encoding_format	string	Non	Format de retour, float (par défaut) ou base64
dimensions	number	Non	Dimensions du vecteur de sortie, dépend du support du modèle
user	string	Non	Identifiant d’utilisateur final

Pour des explications détaillées, consultez la documentation Embeddings.

Formats de réponse

Réponse standard (Non-streaming)

Exemple de réponse standard Chat Completions :

{
  "id": "chatcmpl_xxx",
  "object": "chat.completion",
  "created": 1730000000,
  "model": "gpt-5.5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "RouteAPI est une passerelle API qui unifie l'accès à plusieurs fournisseurs de modèles IA."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 18,
    "total_tokens": 42
  }
}

Champs clés :

• choices[0].message.content — Réponse textuelle du modèle
• choices[0].finish_reason — Raison de l’achèvement (stop / length / tool_calls / content_filter)
• usage — Statistiques d’utilisation des tokens

Réponse streaming (SSE)

Définir stream: true retourne des données incrémentales au format Server-Sent Events (SSE) :

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":"RouteAPI"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":" est"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":24,"completion_tokens":18,"total_tokens":42}}

data: [DONE]

Caractéristiques de la réponse streaming :

• Chaque ligne commence par data: suivi d’un objet JSON
• Le contenu incrémental est dans choices[0].delta.content
• Lorsque terminé, finish_reason n’est pas null
• La dernière ligne est data: [DONE]

Si vous avez besoin de statistiques d’utilisation des tokens en mode streaming, définissez stream_options: { "include_usage": true }, et les informations d’utilisation seront retournées dans le dernier chunk de données.

Réponse d’erreur

Les réponses d’erreur suivent le format standard d’OpenAI :

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

Types d’erreurs courants :

Code de statut HTTP	type	Description
401	invalid_request_error	Clé API invalide ou manquante
429	rate_limit_error	Limite de taux dépassée
500	api_error	Erreur interne du serveur
503	overloaded_error	Service surchargé

Pour la gestion détaillée des erreurs, consultez la documentation de gestion des erreurs.

Différences avec l’API OpenAI officielle

Le protocole compatible OpenAI de RouteAPI est entièrement compatible au niveau du protocole, mais présente quelques différences dans les capacités des modèles, la facturation et la limitation de taux :

Gamme d’ID de modèles plus large

L’API OpenAI officielle ne peut appeler que les propres modèles d’OpenAI (gpt-4o, gpt-5.5, etc.). RouteAPI supporte des modèles de plusieurs fournisseurs :

• OpenAI : gpt-4o, gpt-5.5, o3-mini, etc.
• Anthropic Claude : claude-sonnet-4-5, claude-opus-4, etc.
• Google Gemini : gemini-2.0-flash, gemini-2.5-pro, etc.
• Mistral : mistral-large, mistral-small, etc.
• Autres : DeepSeek, Qwen, LLaMA, etc.

Interrogez la liste complète des modèles disponibles pour le compte actuel via l’endpoint /v1/models.

Facturation et limitation de taux gérées par RouteAPI

• Facturation : Facturé selon la grille tarifaire de RouteAPI, qui peut différer des prix officiels des fournisseurs en amont
• Limitation de taux : Contrôlée par les politiques de limite de taux de RouteAPI, pas par les limites des fournisseurs en amont
• Quotas : Le solde du compte et les quotas sont gérés par RouteAPI, rechargez et consultez dans la console

Le support des paramètres dépend du modèle sous-jacent

Le protocole compatible OpenAI définit un ensemble complet de paramètres, mais le support réel dépend du modèle sélectionné :

Capacité	Description
Appel d’outils (tools)	Dépend si le modèle supporte le function calling
Sortie structurée (response_format)	Dépend si le modèle supporte le mode JSON ou JSON Schema
Entrée visuelle (image_url)	Dépend si le modèle supporte l’entrée multimodale
Utilisation en streaming (stream_options.include_usage)	Dépend si le modèle et le canal supportent les statistiques d’utilisation en streaming
Contrôle du raisonnement (reasoning_effort)	Supporté uniquement par certains modèles de raisonnement

Il est recommandé de valider le support des paramètres clés du modèle sélectionné dans un environnement de test avant d’activer en production.

Gestion des paramètres à valeur zéro explicite

C’est une différence subtile mais importante. Dans le protocole compatible OpenAI, si des paramètres optionnels sont explicitement passés comme 0, 0.0 ou false, RouteAPI les traite comme un paramétrage explicite de l’utilisateur plutôt que de les supprimer comme valeurs par défaut.

Par exemple :

{
  "model": "gpt-5.5",
  "messages": [...],
  "temperature": 0,
  "top_p": 1.0
}

Ici, temperature: 0 sera préservé et transmis au modèle en amont, plutôt que d’être traité comme non défini parce que “la valeur est 0”. Cela garantit que les clients peuvent contrôler précisément les paramètres d’échantillonnage.

Si vous ne voulez pas passer un certain paramètre, supprimez simplement ce champ de la requête ; ne passez pas null ou 0.

Notes de compatibilité

Les capacités dépendent du modèle sélectionné

Le protocole compatible OpenAI est une définition d’interface standard, mais les capacités spécifiques dépendent du modèle sous-jacent :

• Appel d’outils : Nécessite que le modèle supporte le function calling, et que le format de définition d’outils corresponde aux exigences du modèle
• Sortie structurée : Nécessite que le modèle supporte le mode JSON ou JSON Schema
• Entrée visuelle : Nécessite que le modèle supporte l’entrée d’image ou multimodale
• Utilisation en streaming : Nécessite que le modèle et le canal supportent le retour de l’utilisation des tokens en mode streaming

Si la requête inclut des paramètres que le modèle ne supporte pas, le comportement dépend du type de paramètre :

• Les paramètres ignorables (comme frequency_penalty) seront silencieusement ignorés
• Les paramètres critiques (comme tools) peuvent déclencher des erreurs

En production, il est recommandé de fixer les ID de modèles et de préparer des stratégies de repli pour les flux métier critiques.

Validation des paramètres et messages d’erreur

RouteAPI effectue une validation de base sur les paramètres de requête, tels que :

• Paramètres requis manquants (comme model, messages)
• Types de paramètres incorrects (comme passer une chaîne pour temperature)
• Valeurs de paramètres hors limites (comme temperature: 3)

Lorsque la validation échoue, elle retourne 400 Bad Request avec des informations d’erreur détaillées. Si la requête passe la validation de RouteAPI mais est rejetée par le modèle en amont, elle retourne 500 ou 502 avec le message d’erreur original en amont.

Considérations pour la migration entre modèles

Lors du passage d’un modèle à un autre, même si les deux utilisent le protocole compatible OpenAI, les points suivants nécessitent une attention :

1. Longueur de contexte : Différents modèles ont différentes longueurs de contexte maximum ; les requêtes excessivement longues peuvent être rejetées
2. Format d’appel d’outils : Certains modèles ont des exigences plus strictes pour les formats de description d’outils
3. Style de sortie : Le même prompt peut produire différents styles de sortie, longueurs et formats selon les modèles
4. Comptage de tokens : Différents modèles ont différents tokenizers ; le même texte peut avoir différents comptes de tokens
5. Prix de facturation : Différents modèles ont différents prix unitaires ; changer de modèles peut affecter les coûts

Il est recommandé de valider le workflow complet dans un environnement de test avant de changer de modèles en production.

Endpoint /v1/models

L’endpoint /v1/models retourne une liste de modèles disponibles pour le compte actuel, dans un format cohérent avec l’API OpenAI officielle.

Exemple de requête

curl https://api.routeapi.ai/v1/models \
  -H "Authorization: Bearer $ROUTEAPI_KEY"

Exemple de réponse

{
  "success": true,
  "object": "list",
  "data": [
    {
      "id": "gpt-5.5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "openai",
      "supported_endpoint_types": ["openai", "openai-response"]
    },
    {
      "id": "claude-sonnet-4-5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "anthropic",
      "supported_endpoint_types": ["openai", "anthropic"]
    }
  ]
}

Le tableau data retourné contient les modèles disponibles pour le Token actuel, et non le catalogue complet de la plateforme. Chaque objet modèle inclut :

• id — ID du modèle, utilisez cette valeur lors des requêtes
• object — Fixé à "model"
• owned_by — Type de canal auquel appartient le modèle ; custom pour les modèles personnalisés de la plateforme
• supported_endpoint_types — Champ d’extension RouteAPI, les types d’endpoints utilisables pour ce modèle
• created — Valeur de remplacement fixe 1626777600, ce n’est pas une date de mise en ligne réelle ; ne l’utilisez pas pour trier

Le champ success ajouté au niveau supérieur est une extension RouteAPI ; les SDK OpenAI ne lisent que data, cela n’affecte donc pas l’analyse. L’ordre de data n’est pas garanti stable.

Il est recommandé d’appeler /v1/models une fois au démarrage de l’application, de mettre en cache la liste des modèles disponibles et d’éviter les requêtes à chaque demande. Pour la signification des champs et les règles de filtrage, voir Models.

Exemples complets

Conversation de base avec curl

curl https://api.routeapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [
      {
        "role": "system",
        "content": "Vous êtes un assistant technique rigoureux. Gardez les réponses concises."
      },
      {
        "role": "user",
        "content": "Veuillez présenter RouteAPI en une phrase"
      }
    ],
    "temperature": 0.7
  }'

Exemple complet SDK Python

import os
from openai import OpenAI

# Initialiser le client
client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

# Conversation de base
def basic_chat():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": "Vous êtes un assistant technique rigoureux."},
            {"role": "user", "content": "Veuillez présenter RouteAPI en une phrase"}
        ],
        temperature=0.7
    )
    print(response.choices[0].message.content)
    print(f"Utilisation : {response.usage.total_tokens} tokens")

# Conversation en streaming
def streaming_chat():
    stream = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "Expliquez étape par étape ce qu'est une passerelle API"}
        ],
        stream=True,
        stream_options={"include_usage": True}
    )

    for chunk in stream:
        if chunk.choices:
            delta = chunk.choices[0].delta
            if delta.content:
                print(delta.content, end="", flush=True)
        # Le dernier chunk contient l'utilisation
        if hasattr(chunk, 'usage') and chunk.usage:
            print(f"\nUtilisation : {chunk.usage.total_tokens} tokens")

# Appel d'outils
def tool_calling():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Interroger la météo actuelle pour une ville spécifiée",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "Nom de la ville, par ex. Paris"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["city"]
                }
            }
        }
    ]

    messages = [{"role": "user", "content": "Quel temps fait-il à Paris en ce moment ?"}]

    # Premier tour : le modèle demande un appel d'outil
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    # Vérifier les appels d'outils
    if response.choices[0].message.tool_calls:
        # Simuler l'exécution de l'outil
        tool_call = response.choices[0].message.tool_calls[0]
        tool_result = "Paris, ensoleillé, température 23 Celsius, humidité 45%."

        # Construire la requête du deuxième tour
        messages.append(response.choices[0].message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": tool_result
        })

        # Deuxième tour : le modèle génère une réponse basée sur le résultat de l'outil
        final_response = client.chat.completions.create(
            model="gpt-5.5",
            messages=messages,
            tools=tools
        )
        print(final_response.choices[0].message.content)

# Sortie structurée
def structured_output():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "Extraire les informations clés du texte suivant : RouteAPI est une passerelle API IA supportant OpenAI, Claude, Gemini et d'autres modèles."}
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "key_info",
                "strict": True,
                "schema": {
                    "type": "object",
                    "properties": {
                        "product_name": {"type": "string"},
                        "category": {"type": "string"},
                        "supported_models": {
                            "type": "array",
                            "items": {"type": "string"}
                        }
                    },
                    "required": ["product_name", "category", "supported_models"],
                    "additionalProperties": False
                }
            }
        }
    )
    print(response.choices[0].message.content)

if __name__ == "__main__":
    basic_chat()
    print("\n" + "="*50 + "\n")
    streaming_chat()
    print("\n" + "="*50 + "\n")
    tool_calling()
    print("\n" + "="*50 + "\n")
    structured_output()

Exemple complet SDK Node.js

import OpenAI from 'openai';

// Initialiser le client
const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

// Conversation de base
async function basicChat() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'system', content: 'Vous êtes un assistant technique rigoureux.' },
      { role: 'user', content: 'Veuillez présenter RouteAPI en une phrase' }
    ],
    temperature: 0.7
  });

  console.log(response.choices[0].message.content);
  console.log(`Utilisation : ${response.usage.total_tokens} tokens`);
}

// Conversation en streaming
async function streamingChat() {
  const stream = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'user', content: 'Expliquez étape par étape ce qu\'est une passerelle API' }
    ],
    stream: true,
    stream_options: { include_usage: true }
  });

  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
    if (chunk.usage) {
      console.log(`\nUtilisation : ${chunk.usage.total_tokens} tokens`);
    }
  }
}

// Appel d'outils
async function toolCalling() {
  const tools = [
    {
      type: 'function',
      function: {
        name: 'get_weather',
        description: 'Interroger la météo actuelle pour une ville spécifiée',
        parameters: {
          type: 'object',
          properties: {
            city: {
              type: 'string',
              description: 'Nom de la ville, par ex. Paris'
            },
            unit: {
              type: 'string',
              enum: ['celsius', 'fahrenheit']
            }
          },
          required: ['city']
        }
      }
    }
  ];

  const messages = [
    { role: 'user', content: "Quel temps fait-il à Paris en ce moment ?" }
  ];

  // Premier tour
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: messages,
    tools: tools,
    tool_choice: 'auto'
  });

  // Vérifier les appels d'outils
  if (response.choices[0].message.tool_calls) {
    const toolCall = response.choices[0].message.tool_calls[0];
    const toolResult = 'Paris, ensoleillé, température 23 Celsius, humidité 45%.';

    // Deuxième tour
    messages.push(response.choices[0].message);
    messages.push({
      role: 'tool',
      tool_call_id: toolCall.id,
      content: toolResult
    });

    const finalResponse = await client.chat.completions.create({
      model: 'gpt-5.5',
      messages: messages,
      tools: tools
    });

    console.log(finalResponse.choices[0].message.content);
  }
}

// Sortie structurée
async function structuredOutput() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      {
        role: 'user',
        content: 'Extraire les informations clés du texte suivant : RouteAPI est une passerelle API IA supportant OpenAI, Claude, Gemini et d\'autres modèles.'
      }
    ],
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'key_info',
        strict: true,
        schema: {
          type: 'object',
          properties: {
            product_name: { type: 'string' },
            category: { type: 'string' },
            supported_models: {
              type: 'array',
              items: { type: 'string' }
            }
          },
          required: ['product_name', 'category', 'supported_models'],
          additionalProperties: false
        }
      }
    }
  });

  console.log(response.choices[0].message.content);
}

// Exécuter les exemples
async function main() {
  await basicChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await streamingChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await toolCalling();
  console.log('\n' + '='.repeat(50) + '\n');
  await structuredOutput();
}

main().catch(console.error);

Recommandations d’intégration

• Priorisez le protocole compatible OpenAI si votre client, SDK ou outil supporte nativement l’API OpenAI
• Fixez les ID de modèles, ne vous fiez pas aux alias temporaires ou aux noms d’affichage en production
• Enregistrez les métadonnées de requête, incluant l’ID de requête, l’ID de modèle, le code de statut, la latence et l’utilisation des tokens
• Activez les réessais en cas d’échec, activez les réessais client et les options de modèles alternatifs pour les flux métier critiques
• Validez les capacités optionnelles, testez l’appel d’outils, la sortie structurée, l’entrée visuelle et d’autres capacités dans un environnement de test d’abord
• Surveillez les coûts et quotas, vérifiez régulièrement les journaux d’utilisation et les détails de facturation dans la console
• Protégez les clés API, encapsulez les tokens RouteAPI côté serveur et évitez d’exposer les clés directement aux frontends métier

Si le client ne supporte que le protocole Claude Messages ou Google Gemini, utilisez les endpoints de protocole correspondants ; consultez les documentations Claude Messages et Gemini API.