Complétions de chat

L’API Chat Completions d’OpenAI, pour tous les modèles de texte : mêmes requêtes et réponses, même streaming, mêmes SDK.

Requête

Réponse

{
  "id": "chatcmpl-AbC123...",
  "object": "chat.completion",
  "created": 1790870400,
  "model": "claude-opus-5-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Here's the summary..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1204,
    "completion_tokens": 312,
    "total_tokens": 1516,
    "prompt_tokens_details": { "cached_tokens": 1024 },
    "completion_tokens_details": { "reasoning_tokens": 128 }
  }
}

• model est le modèle qui a répondu. C’est celui que vous avez demandé, sauf si le routage intelligent a fait appel à un autre modèle.
• Les modèles de raisonnement peuvent ajouter reasoning_content au message : il contient le raisonnement du modèle, lorsque celui-ci le partage.
• usage correspond à ce qui vous est facturé. cached_tokens correspond aux tokens d’entrée lus dans le cache de prompts du modèle, facturés au tarif de mise en cache si le modèle en propose un.

Chaque réponse contient aussi ces en-têtes :

Streaming

Avec stream: true, la réponse arrive sous forme de server-sent events au format de fragments d’OpenAI, et se termine par data: [DONE]. Chaque SDK les lit pour vous.

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
stream = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[
      {
        "role": "user",
        "content": "Write a limerick about databases."
      }
    ],
    stream=True,
    stream_options={
      "include_usage": True
    },
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

• Aucune réponse n’est envoyée avant que le modèle ait produit son premier token : une nouvelle tentative ou un changement de voie reste donc invisible pour vous.
• Pendant les périodes sans activité (quand un modèle réfléchit entre deux étapes), des lignes de commentaire SSE (: keep-alive) sont envoyées toutes les 15 secondes. Les clients les ignorent ; elles empêchent les proxys de fermer la connexion. Si le premier token prend plus de 20 secondes (prompt long, ou voie bloquée en cours de remplacement), le flux s’ouvre à ce moment-là : les en-têtes et les commentaires de maintien de connexion arrivent pendant que vous attendez. Chaque voie dispose de 3 minutes pour démarrer (5 avec un effort de raisonnement élevé) avant de passer à la suivante ; réglez donc le délai d’expiration de votre client sur 10 minutes.
• Un flux ouvert avant son premier token ne contient x-zurelay-model que si aucun autre modèle ne peut répondre (routage intelligent désactivé), et toute erreur survenant après son ouverture arrive sous forme d’événement d’erreur dans le flux (au même format que le corps d’une réponse d’erreur), plutôt qu’avec un statut d’erreur.
• Avec include_usage, le dernier fragment avant [DONE] contient une liste choices vide et usage.

Appel d’outils

Décrivez les fonctions dans tools ; lorsque le modèle souhaite en appeler une, il répond avec tool_calls au lieu de texte. Exécutez la fonction, renvoyez le résultat dans un message tool avec l’ID de l’appel, et le modèle poursuit.

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[
      {
        "role": "user",
        "content": "What's the weather in Lisbon right now?"
      }
    ],
    tools=[
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Current weather for a city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": {
                "type": "string"
              }
            },
            "required": [
              "city"
            ]
          }
        }
      }
    ],
)
print(response.choices[0].message.content)

Sortie structurée

Demandez du JSON avec response_format. Un json_schema impose votre schéma aux modèles qui le prennent en charge ; json_object demande n’importe quel JSON valide (précisez-le aussi dans votre prompt).

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[
      {
        "role": "user",
        "content": "Extract the people: 'Ana met Ben and Chloe in Porto.'"
      }
    ],
    response_format={
      "type": "json_schema",
      "json_schema": {
        "name": "people",
        "schema": {
          "type": "object",
          "properties": {
            "names": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "required": [
            "names"
          ]
        }
      }
    },
)
print(response.choices[0].message.content)

Raisonnement

Les modèles de raisonnement réfléchissent avant de répondre. Réglez reasoning_effort pour trouver le bon équilibre entre vitesse, coût et profondeur : un niveau plus élevé prolonge la réflexion, prend plus de temps et consomme davantage de tokens de sortie. Chaque modèle accepte les niveaux documentés par son fournisseur, de none (sans réflexion) à max, en passant par minimal, low, medium, high et xhigh (très élevé) ; le tableau ci-dessous les répertorie. Si vous omettez ce paramètre, le modèle utilise son réglage par défaut. Il fonctionne de la même façon avec tous les SDK OpenAI, et vous pouvez essayer chaque niveau dans le Playground du tableau de bord.

from openai import OpenAI
client = OpenAI(base_url="https://api.zurelay.com/v1", api_key="YOUR_ZURELAY_KEY")
response = client.chat.completions.create(
    model="zurelay-auto",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "How many primes are there below 1,000?"}],
)
message = response.choices[0].message
print(getattr(message, "reasoning_content", None))  # the thinking, when the model shares it
print(message.content)

Le raisonnement est renvoyé avec la réponse dans message.reasoning_content (en streaming, dans delta.reasoning_content) pour les modèles qui le partagent ; certains nomment ce champ reasoning. Il est facturé comme des tokens de sortie et fait toujours partie de completion_tokens ; completion_tokens_details.reasoning_tokens le comptabilise séparément quand le modèle fournit ce détail. À un niveau d’effort élevé, la réponse peut mettre plusieurs minutes à démarrer : prévoyez donc un délai d’expiration généreux côté client (voir Fiabilité et délais d’expiration).

Niveaux par modèle

Ces niveaux proviennent de la documentation de chaque labo. Si un modèle n’accepte pas le niveau demandé, il utilise le plus proche parmi ceux qu’il accepte (en cas d’égalité, le plus bas ; le raisonnement ne se désactive que si vous envoyez none). Une même requête fonctionne ainsi sur tous les modèles, y compris avec le routage intelligent. L’en-tête de réponse x-zurelay-reasoning-effort indique le niveau utilisé. Un mot qui ne correspond à aucun niveau est refusé avec une erreur 400 qui liste les niveaux du modèle.

Le raisonnement de Claude

Sur cet endpoint, Claude accepte reasoning_effort comme tout autre modèle : low, medium, high, xhigh ou max (Opus 4.6 ne propose pas xhigh). Dans le format natif d’Anthropic, Claude adapte son raisonnement au niveau choisi : envoyez thinking: { type: "adaptive", display: "summarized" } avec output_config: { effort: "xhigh" } et lisez les blocs de raisonnement. Voir Anthropic Messages.