Chatcompletions

De Chat Completions API van OpenAI, voor elk tekstmodel: dezelfde verzoeken en antwoorden, dezelfde streaming, dezelfde SDK's.

Verzoek

Antwoord

{
  "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 is het model dat heeft geantwoord. Dat is het model dat je hebt gevraagd, tenzij slimme routering een alternatief heeft gebruikt.
• Redeneermodellen kunnen reasoning_content aan het bericht toevoegen: de denkstappen van het model, als het die deelt.
• usage is wat je in rekening wordt gebracht. cached_tokens zijn invoertokens die uit de promptcache van het model worden gelezen, gefactureerd tegen het cachetarief als het model dat heeft.

Elk antwoord bevat ook deze headers:

Streaming

Met stream: true komt het antwoord binnen als server-sent events in het chunkformaat van OpenAI, eindigend met data: [DONE]. Elke SDK leest deze voor je.

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)

• Er wordt pas een antwoord verstuurd zodra het model zijn eerste token heeft geproduceerd, zodat je niets merkt van een nieuwe poging of een overstap naar een andere route.
• Tijdens stille periodes (als een model tussen stappen nadenkt) worden elke 15 seconden SSE-commentaarregels (: keep-alive) verstuurd. Clients negeren ze; ze voorkomen dat proxy’s de verbinding sluiten. Duurt het eerste token langer dan 20 seconden (door een lange prompt, of een vastgelopen route die wordt vervangen), dan opent de stream alvast: de headers en keep-alive-commentaarregels komen binnen terwijl je wacht. Elke route krijgt maximaal 3 minuten om te starten (5 bij een hoog redeneerniveau) voordat de volgende wordt geprobeerd, dus stel de time-out van je client in op 10 minuten.
• Een stream die vóór het eerste token is geopend, bevat alleen x-zurelay-model als geen ander model kan antwoorden (slimme routering uit). Een fout na het openen komt binnen als een foutevent in de stream (met dezelfde structuur als de foutbody), in plaats van een foutstatus.
• Met include_usage bevat de laatste chunk vóór [DONE] een lege lijst voor choices en de usage.

Tools aanroepen

Beschrijf functies in tools; als het model er een wil aanroepen, antwoordt het met tool_calls in plaats van tekst. Voer de functie uit, stuur het resultaat terug als een tool-bericht met de ID van de aanroep, en het model gaat verder.

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)

Gestructureerde uitvoer

Vraag om JSON met response_format. Een json_schema dwingt modellen die dit ondersteunen om je schema te volgen; json_object vraagt om willekeurige geldige JSON (vermeld dit ook in je 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)

Redeneren

Redeneermodellen denken na voordat ze antwoorden. Stel reasoning_effort in om snelheid en kosten af te wegen tegen diepgang: een hoger niveau denkt langer na, kost meer tijd en gebruikt meer uitvoertokens. Elk model ondersteunt de niveaus die de aanbieder documenteert, van none (niet nadenken) via minimal, low, medium, high en xhigh (extra hoog) tot max; de tabel hieronder geeft ze weer. Laat je het weg, dan gebruikt het model zijn standaardniveau. Het werkt hetzelfde met elke OpenAI SDK, en je kunt elk niveau proberen in de Playground van het dashboard.

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)

Bij modellen die hun denkstappen delen, krijg je die samen met het antwoord in message.reasoning_content (bij streaming in delta.reasoning_content); sommige noemen het veld reasoning. Ze worden gefactureerd als uitvoertokens en tellen altijd mee in completion_tokens; completion_tokens_details.reasoning_tokens telt ze apart als het model dat rapporteert. Bij een hoog redeneerniveau kan het minuten duren voordat een antwoord begint, dus geef je client een ruime time-out (zie Betrouwbaarheid en time-outs).

Niveaus per model

Uit de documentatie van elke aanbieder zelf. Een niveau dat een model niet ondersteunt, wordt uitgevoerd op het dichtstbijzijnde ondersteunde niveau (bij twee even nabije niveaus het laagste; nadenken gaat alleen uit als je none stuurt), zodat één verzoek op elk model werkt, ook met slimme routering. De antwoordheader x-zurelay-reasoning-effort geeft aan welk niveau is gebruikt. Een woord dat geen niveau is, wordt geweigerd met een 400 die de niveaus van het model vermeldt.

Hoe Claude nadenkt

Via dit endpoint accepteert Claude reasoning_effort net als elk ander model: low, medium, high, xhigh of max (Opus 4.6 heeft geen xhigh). In het eigen formaat van Anthropic denkt Claude adaptief op een bepaald niveau: stuur thinking: { type: "adaptive", display: "summarized" } met output_config: { effort: "xhigh" } en lees de denkblokken. Zie Anthropic Messages.