Un modèle de raisonnement réfléchit avant de répondre, et sur la plupart des API compatibles OpenAI, les deux puisent dans un seul budget : max_tokens. Réglez-le comme pour un modèle sans raisonnement, quelques centaines de tokens pour une réponse courte, et certaines réponses reviennent vides avec finish_reason: "length". La correction rapide se trouve dans pourquoi un modèle de raisonnement renvoie une réponse vide. Cet article présente la méthode derrière un budget fiable : mesurer, dimensionner à partir des percentiles, respecter la fenêtre de contexte, et gérer les réponses qui restent coupées.
Pour ce que coûte le raisonnement et comment le réduire, voir tokens de raisonnement : pourquoi vous payez plus de sortie que vous n’en voyez.
Pourquoi le budget s’épuise-t-il avant la réponse ?
Le modèle génère dans l’ordre : d’abord son raisonnement, puis la réponse visible. Chaque token des deux compte dans max_tokens. La documentation de BroadNet le dit pour DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B : « the reasoning counts toward max_tokens » (traduction : « le raisonnement compte dans max_tokens »), et avec une limite basse « the answer comes back empty » (traduction : « la réponse revient vide »). La référence Chat Completions d’OpenAI définit max_completion_tokens de la même façon, comme une borne supérieure « including visible output tokens and reasoning tokens » (traduction : « incluant les tokens de sortie visibles et les tokens de raisonnement »).
La question à se poser n’est donc pas « quelle est la longueur de ma réponse ? », mais « quelle est la longueur du raisonnement et de la réponse ensemble, sur cette tâche, à cet effort ? ». Cela varie plus qu’on ne le pense. Le guide d’OpenAI indique que ses modèles peuvent générer « anywhere from a few hundred to tens of thousands of reasoning tokens » (traduction : « de quelques centaines à des dizaines de milliers de tokens de raisonnement »), selon le problème.
Un max_tokens plus grand coûte-t-il plus cher ?
Non. C’est la raison la plus fréquente des budgets trop serrés. max_tokens est un plafond. Vous êtes facturé pour les tokens réellement générés. Une réponse qui a besoin de 1 800 tokens coûte la même chose avec un plafond de 4 000 ou de 40 000.
Ce que coûte un plafond serré :
| Plafond par rapport au besoin | Ce que vous payez | Ce que vous obtenez |
|---|---|---|
| Plafond au-dessus du besoin | Les tokens générés | La réponse |
| Plafond en dessous du besoin | Le plafond entier, uniquement du raisonnement | Rien d’exploitable, plus une relance |
Prenons une illustration. Supposons qu’un quart de vos appels ait besoin de plus de 1 000 tokens. Avec max_tokens=1000, chacun de ces appels facture 1 000 tokens de sortie de réflexion, ne renvoie rien et doit être relancé. Cela ajoute en moyenne 250 tokens de sortie gaspillés par appel sur l’ensemble des appels, avant même les relances, plus la latence d’une deuxième requête. Avec un plafond à 4 000, rien n’est gaspillé. Sur Qwen3.8 27B, la sortie coûte $2.17 par million de tokens : le gaspillage s’accumule vite à grande échelle.
Le vrai risque d’un plafond élevé est une réponse qui s’emballe : un modèle qui boucle ou réfléchit trop et génère bien plus que nécessaire. Un plafond strict limite ce risque. Choisissez-le à partir des données, comme ci-dessous.
Comment mesurer ce dont une tâche a besoin ?
Faites tourner des prompts réels pour un type de tâche avec un plafond généreux, et enregistrez les tokens de complétion et la part de raisonnement. Quand le modèle la fournit, usage.completion_tokens_details.reasoning_tokens donne la part de raisonnement ; la documentation de BroadNet liste ce champ.
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"
def measure(prompts, ceiling=16_000, **kw):
"""Run real prompts with a generous ceiling and return per-call token counts."""
rows = []
for p in prompts:
r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
messages=[{"role": "user", "content": p}], **kw)
u, d = r.usage, r.usage.completion_tokens_details
reasoning = (d.reasoning_tokens or 0) if d else 0
rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
"finish": r.choices[0].finish_reason})
return rows
def pct(values, q):
values = sorted(values)
return values[min(len(values) - 1, int(q * len(values)))]
def recommend(rows, margin=1.2):
total = [r["reasoning"] + r["answer"] for r in rows]
return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
"max_tokens": int(pct(total, 0.95) * margin),
"cut_off": sum(r["finish"] == "length" for r in rows)}
# print(recommend(measure(my_prompts))) # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
Règles pour obtenir un chiffre fiable :
- Un type de tâche par série. Classification, extraction, revue de code et planification ont des distributions très différentes. Un
max_tokensglobal soit gaspille de l’argent en relances, soit laisse passer les réponses qui s’emballent. - 50 prompts réels ou plus. Le 95e percentile de dix échantillons n’est que le plus grand d’entre eux.
- Mesurez à chaque niveau d’effort utilisé.
reasoning_effort="low"modifie la distribution. BroadNet documentelow; testez les autres valeurs avant de vous y fier. - Si
cut_offn’est pas nul, relevez le plafond et recommencez. Un échantillon coupé cache sa vraie longueur. - Recommencez quand le modèle ou le prompt change. Une nouvelle version du modèle peut réfléchir plus ou moins.
Réglez ensuite max_tokens par tâche à partir de recommend(). Le 95e percentile plus 20 % laisse la plupart des appels bien en dessous du plafond et n’envoie que les rares cas longs vers le chemin de relance ci-dessous. L’outil gratuit de budget de tokens de raisonnement fait ce calcul dans votre navigateur une fois que vous avez vos chiffres.
Comment la fenêtre de contexte limite-t-elle le budget ?
La fenêtre de contexte contient le prompt et la réponse ensemble. Le flux de prix de BroadNet définit context_length comme « the most tokens one request can hold, prompt and answer together » (traduction : « le nombre maximal de tokens qu’une requête peut contenir, prompt et réponse ensemble »). Donc :
max_tokens ≤ longueur du contexte − tokens du prompt
| Modèle | Contexte | Place pour max_tokens avec un prompt de 200 000 tokens |
|---|---|---|
| GLM 5.3 | 1 048 576 | 848 576 |
| DeepSeek V4.1 Flash | 1 048 576 | 848 576 |
| Qwen3.8 27B | 262 144 | 62 144 |
Cela compte pour le travail en contexte long. Un agent dont l’historique a atteint 250 000 tokens sur Qwen3.8 27B n’a plus qu’environ 12 000 tokens pour réfléchir et répondre. Les tâches en contexte long demandent aussi souvent plus de raisonnement : vérifiez donc la place restante au moment de l’appel, pas une seule fois au démarrage. Fenêtre de contexte et le calculateur de fenêtre de contexte vous aident à vérifier que tout tient.
Que faire quand une réponse est quand même coupée ?
Vérifiez finish_reason à chaque appel. S’il vaut length, la réponse manque ou est incomplète, même si content contient du texte. Ne l’analysez pas comme si elle était complète ; un objet JSON tronqué est une source fréquente d’erreurs en aval (sortie structurée).
Relancez avec un budget doublé, dans la place que laisse le contexte, jusqu’à un plafond strict :
import json, urllib.request
FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}
def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
"""Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
while True:
r = client.chat.completions.create(model=model, messages=messages,
max_tokens=budget, **kw)
if r.choices[0].finish_reason != "length":
return r
room = CONTEXT[model] - r.usage.prompt_tokens # context holds prompt + answer
nxt = min(budget * 2, hard_cap, room)
if nxt <= budget:
raise RuntimeError(f"still cut off at max_tokens={budget}")
print(f"cut off at {budget}, retrying with {nxt}")
budget = nxt
Deux alternatives au doublement, selon la tâche :
- Relancer avec
reasoning_effort="low"et le même budget. Sur les tâches simples, le modèle réfléchit souvent trop, et moins d’effort règle le problème sans relever le plafond. - Découper la tâche. Si une réponse atteint sans cesse un plafond élevé, la requête en demande généralement trop à la fois.
Journalisez chaque coupure avec le type de tâche. Un taux en hausse signifie que le prompt, le modèle ou les données d’entrée ont changé, et que le budget doit être remesuré. Les relances sont de nouvelles inférences et sont facturées à nouveau : limitez donc le nombre de tentatives, comme dans agents de longue durée : timeouts et relances.
Qu’est-ce que le streaming change ?
Avec stream=True, le raisonnement a lieu avant le premier token visible : un modèle de raisonnement peut donc sembler bloqué au début. Dans une interface de chat, affichez un état « réflexion en cours » jusqu’à l’arrivée du contenu, et dimensionnez les timeouts du client pour le temps de réflexion, pas seulement pour la réponse.
Certains serveurs diffusent aussi le texte du raisonnement lui-même, dans un champ séparé. Son nom n’est pas standard : l’API de DeepSeek utilise reasoning_content, et vLLM a renommé son champ de reasoning_content en reasoning, en prévenant que l’ancien code client « could silently read an empty » (traduction : « pourrait lire silencieusement un champ vide »). La documentation de BroadNet ne documente aucun champ de texte de raisonnement : ne construisez donc pas de fonctionnalité dessus sans vérifier la réponse brute pour votre modèle. Si vous le lisez, faites-le de manière défensive :
for chunk in stream:
if chunk.choices:
delta = chunk.choices[0].delta
thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
# log or display `thinking` only if your provider actually sends it
if delta.content:
print(delta.content, end="")
elif chunk.usage: # last chunk, with include_usage
print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
L’usage dans le dernier chunk nécessite stream_options={"include_usage": True}, que BroadNet documente. Plus de détails sur les flux dans le guide du streaming et SSE expliqué.
Quel nom de paramètre envoyer ?
| API | Paramètre | Inclut le raisonnement |
|---|---|---|
| OpenAI Chat Completions | max_completion_tokens (max_tokens obsolète) |
Oui |
| OpenAI Responses | max_output_tokens |
Oui |
| BroadNet Inference (Chat Completions) | max_tokens, comme documenté |
Oui |
| Serveurs vLLM | max_tokens, plus thinking_token_budget en option |
Oui |
Quand vous déplacez du code d’un fournisseur à l’autre, envoyez le nom que le fournisseur documente, et confirmez avec un appel de test que la limite s’applique. Une limite ignorée en silence semble fonctionner jusqu’à l’arrivée d’une réponse qui s’emballe. La checklist de migration couvre les autres paramètres qui changent.
La place de BroadNet Inference
Les trois modèles de raisonnement de BroadNet indiquent les tokens de raisonnement dans usage quand le modèle les fournit : la mesure ci-dessus fonctionne donc telle quelle. DeepSeek V4.1 Flash et GLM 5.3 offrent le plus de place, avec 1 048 576 tokens de contexte. Qwen3.8 27B en a 262 144. Si une tâche n’a pas besoin de raisonnement, Gemma 4 VL 26B n’est pas listé comme modèle de raisonnement et évite complètement la question du budget. Sur un forfait DeepSeek V4.1 Flash à prix fixe, les tokens de réflexion ne sont pas facturés au token, mais les réponses coupées coûtent quand même du temps : la même méthode de budget s’applique. BroadNet ne documente pas de plafond de raisonnement séparé ; si vous en avez besoin, utilisez un fournisseur ou un serveur auto-hébergé qui le propose.
