Pourquoi Tencent Hy4 épuise ses tokens avant de répondre
Sommaire
- Que s’est-il passé avec le résumé de l’incident du catalogue ?
- Comment diagnostiquer une réponse vide ?
- Que contrôlent les paramètres de raisonnement et de sortie de Hy4 ?
- Le cas 2 a-t-il de nouveau été tronqué à 8,192 tokens ?
- Quels résultats pour les quatre niveaux de raisonnement ?
- Comment le client doit-il gérer cet échec de Hy4 ?
- Comment Hy4 et DeepSeek ont-ils traité les mêmes cas ?
- Qu’avons-nous demandé au modèle ?
- FAQ
- Que se passe-t-il lorsqu’une réponse dépasse la limite client de 128 Kio ?
- Comment vérifier que Hy4 a respecté reasoning_effort none ?
Tencent Hy4 a renvoyé HTTP 200 avec une réponse finale vide pour le résumé d’un incident synthétique. Il indiquait 8,192 tokens de raisonnement, soit exactement la limite de sortie demandée. Sur cette route API, le raisonnement et la réponse finale partagent le même budget. Un client qui vérifie uniquement le statut HTTP peut donc considérer comme terminé un résumé qui a épuisé ses tokens.
TL;DR
- Hy4 a renvoyé HTTP 200 avec une réponse finale vide après avoir consacré les 8,192 tokens de sortie au raisonnement.
- La réponse s’est terminée avec
finish_reason: "length"et mesurait 68,410 octets, sous la limite client de 128 Kio. - Sur quatre incidents fondés sur des règles,
nonea conservé les faits essentiels dans les deux langues et ramené la taille médiane du corps de réponse de 51,780 à 1,467 octets par rapport àmedium.
Que s’est-il passé avec le résumé de l’incident du catalogue ?
Nous avons demandé à Hy4 de résumer un incident fictif en anglais et en chinois, d’en évaluer la gravité selon une règle fixe et de citer en JSON les événements de panne et de reprise. Pour le cas du catalogue avec un effort moyen, l’API a renvoyé HTTP 200 et finish_reason: "length". Elle indiquait 8,192 tokens de raisonnement pour une limite de sortie de 8,192 tokens, et message.content était vide. La réponse complète mesurait 68,410 octets, sous la limite client de 128 Kio.
Comment diagnostiquer une réponse vide ?
| Ce que voit le client | Ce qu’il faut vérifier |
|---|---|
| La requête expire avant la réception des en-têtes | Enregistrez l’exception de transport et le temps écoulé. Le client ne dispose d’aucun statut ni corps de réponse à examiner. |
| Le lecteur atteint sa limite d’octets | Enregistrez la limite et le nombre d’octets reçus. Le client a peut-être interrompu la lecture avant de pouvoir analyser la réponse. |
| La réponse complète contient un résultat final vide ou partiel | Vérifiez finish_reason, message.content et usage.completion_tokens_details.reasoning_tokens. Dans le cas du catalogue, length et un nombre de tokens de raisonnement égal à la limite de sortie indiquent où la génération s’est arrêtée. |
Vérifiez que la génération est terminée avant de transmettre la réponse aux traitements suivants. Même si le contenu final est un JSON valide et que ses champs semblent corrects, un motif de fin length indique que la génération a atteint une limite. Une fois la génération terminée, validez la réponse finale par rapport aux données d’entrée.
Conservez ensemble le statut d’origine de la réponse et son motif de fin dans les logs de requêtes. Si les deux cas sont ramenés à une erreur générique « JSON invalide », le monitoring ne permet plus de distinguer une réponse manquante d’une réponse complète contenant un champ incorrect. Ces cas ne se diagnostiquent pas de la même façon. Pour le premier, vérifiez le budget et l’achèvement de la génération. Pour le second, vérifiez le prompt, les valeurs attendues et les règles de validation.
Que contrôlent les paramètres de raisonnement et de sortie de Hy4 ?
Le paramètre de requête reasoning_effort indique le niveau de raisonnement demandé avant la réponse finale. La documentation TokenHub de Tencent expose deux réglages pour le raisonnement de Hy4. Le champ thinking.type l’active ou le désactive avec enabled ou disabled. Il est activé par défaut. Dans le tableau propre aux modèles, Hy4 accepte high et no_think pour reasoning_effort, avec high par défaut. Les options diffèrent pour les autres modèles. Lorsque vous déplacez une requête d’un fournisseur à l’autre, consultez la ligne correspondant exactement à l’ID du modèle. Guide Tencent TokenHub sur le raisonnement approfondi
Avec Synthorai Chat Completions, nous avons envoyé none, low, medium et high comme niveaux d’effort demandés. La documentation TokenHub décrit son propre endpoint. Nos mesures reflètent le comportement des requêtes Synthorai, sans établir la correspondance de chaque niveau d’effort en amont. Sur la route Synthorai testée, none a renvoyé une réponse finale avec zéro token de raisonnement déclaré lors des 12 répétitions. Utilisez cette mesure comme test de compatibilité pour la route appelée par votre application. Si vous changez d’endpoint ou d’ID de modèle, relancez une sonde avec une entrée connue. Vérifiez l’utilisation du raisonnement et le contenu final avant de déployer le changement.
La limite de sortie est un réglage distinct. Nous avons utilisé max_tokens pour fixer le plafond de génération demandé. Si le modèle atteint ce plafond avant de commencer la réponse finale, même un prompt qui demande un petit objet JSON peut produire un contenu vide. Dans son exemple Hy3, le guide de dépannage de Tencent explique que le raisonnement et la réponse partagent le même quota. Notre mesure sur Hy4 confirme le même type d’échec sur la route Synthorai testée, les 8,192 tokens ayant tous été comptabilisés comme raisonnement. Guide Tencent sur l’API Hy
Le budget de sortie limite la génération. La limite d’octets du client détermine la quantité du corps HTTP qu’il lit, y compris les éventuels champs de raisonnement. Réglez ces deux limites séparément, avec la même entrée et le même paramètre de raisonnement.
Le cas 2 a-t-il de nouveau été tronqué à 8,192 tokens ?
Nous avons rejoué trois fois le cas du catalogue avec Hy4, un effort moyen et une limite de 8,192 tokens. Les trois exécutions ont réussi et indiqué entre 5,106 et 7,155 tokens de raisonnement. Pour la comparaison à 16,384 tokens, nous avons réutilisé les trois requêtes du catalogue à effort moyen issues de l’expérience à quatre réglages ci-dessous. Les trois ont réussi. Les requêtes à 8,192 tokens ont été exécutées ensuite. La première requête à 8,192 tokens avait été tronquée, tandis que les trois suivantes avec la même limite sont arrivées à terme. Ces répétitions ne portent que sur une entrée, les deux limites ayant été testées successivement. Nous ne pouvons pas encore déterminer l’effet d’une limite plus élevée sur le taux de troncature.
Quels résultats pour les quatre niveaux de raisonnement ?
Nous avons rejoué les quatre mêmes cas sur Hy4 via Synthorai, trois fois par cas et par niveau d’effort demandé. Le prompt, la limite de 16,384 tokens, la limite de lecture de 512 Kio et le timeout de socket client de 120 secondes sont restés identiques. Nous avons d’abord testé medium et none ensemble, puis low et high dans un lot ultérieur.
| Effort demandé | Contrôles des champs JSON réussis | Tokens de raisonnement déclarés | Taille médiane mesurée du corps de réponse |
|---|---|---|---|
none | 12/12 | Toujours 0 | 1,467 octets |
low | 11/12 | 2,575 à 11,181 | 42,047 octets |
medium | 12/12 | 2,989 à 9,317 | 51,780 octets |
high | 12/12 | 2,911 à 9,987 | 58,369.5 octets |
La plage de tokens et la médiane de taille du groupe low reposent sur ses 11 réponses mesurées. Chacun des trois autres groupes compte 12 mesures. Les plages observées pour les requêtes envoyées avec low, medium et high se chevauchent. Une réponse low a déclaré 11,181 tokens de raisonnement, soit davantage que toutes les réponses medium mesurées lors de ce test.
Pour chaque réponse complète, nous avons comparé les deux résumés et l’explication du risque aux événements sources. Dans les deux langues, les résumés ont conservé le service affecté, les deux événements HTTP 503 et la reprise confirmée. Les explications ont appliqué la règle de gravité fournie et présenté le signal associé comme une observation. Ces vérifications couvrent la fidélité factuelle de quatre cas utilisant un modèle commun et une règle de gravité explicite.
Comment le client doit-il gérer cet échec de Hy4 ?
Prenons un worker qui publie un résumé en anglais et en chinois lorsque l’incident du catalogue est clos. Il dispose déjà des événements sources et consigne donc les faits qu’il peut vérifier dans le code. Le service de catalogue a renvoyé deux réponses HTTP 503 aux événements 31 et 36, puis l’événement 49 a confirmé la reprise. La règle de notation donne une gravité de 3. Ces valeurs servent à la fois de critères d’acceptation et de données de repli si la génération du résumé échoue.
- N’acceptez qu’un résumé terminé et validé. Le worker lit la réponse dans la limite d’octets configurée et vérifie que le motif de fin est
stopavant d’examiner le JSON final. Pour être publié, l’objet doit désigner le service de catalogue, indiquer une gravité de 3 et citer[31, 36, 49]dans cet ordre. Pendant le déploiement, validez les deux langues par rapport aux mêmes événements. Chaque résumé doit mentionner les pannes et la reprise confirmée. L’explication du risque peut citer la saturation observée du pool de connexions, mais toute relation de causalité exige des preuves supplémentaires. Un motif de finlengthfait échouer la validation, même si le contenu partiel est un JSON valide. - Retentez une seule fois la réponse vide, avec une limite claire. Dans cet exemple, la première requête utilise
mediumet une limite de 8,192 tokens. Si elle renvoielength, un contenu vide et un nombre de tokens de raisonnement égal à la limite, le worker peut réessayer avecnone, à condition que ce réglage ait été validé sur sa propre charge. Conservez le même prompt et la même limite de tokens. Notre comparaison avecnoneutilisait 16,384 tokens. Validez donc la nouvelle tentative à 8,192 avant de l’adopter. Conservez l’échec initial dans le journal des tentatives et appliquez les mêmes contrôles d’acceptation à la nouvelle tentative. Dans le script d’exemple, le timeout de socket de 120 secondes s’applique à chaque appel. Le worker ne doit réessayer que si le temps restant permet de terminer avant l’échéance globale du job. - Renvoyez un état de repli explicite si la nouvelle tentative échoue ou si le délai expire. Définissez l’état du résumé sur
failedoupending_review, selon qu’une revue humaine est prévue ou non, et laissez les deux champs de résumé généré vides. Conservez les métadonnées vérifiées de l’incident et les ID des événements sources afin que le client puisse toujours consulter les preuves. Enregistrez séparément le résultat de la première tentative et celui de la nouvelle tentative. Même si la seconde réussit et fournit un résumé, la première réponse vide doit rester visible dans le monitoring.
Si vous conservez le raisonnement pour des charges nécessitant une appréciation, dimensionnez le budget de sortie à partir de l’utilisation mesurée sur des entrées représentatives, en comptant à la fois le raisonnement et la réponse finale. Mesurez séparément la taille totale des corps avant de fixer la limite du lecteur, car l’enveloppe de réponse fait aussi partie des octets que l’application doit mettre en mémoire tampon. Tenez compte du pic de concurrence pour choisir cette limite. Évaluez le déploiement selon la proportion de requêtes qui produisent un résumé complet et correct, en comptant les timeouts dans le dénominateur. Examinez séparément la qualité factuelle des résumés renvoyés, notamment si les preuves étayent les jugements que la règle de notation laisse au modèle.
Comment Hy4 et DeepSeek ont-ils traité les mêmes cas ?
Nous avons envoyé chacun des quatre prompts via Synthorai, une fois par modèle et par limite. Hy4 et DeepSeek V4.1 Flash (1017) ont tous deux reçu une requête demandant un effort de raisonnement moyen. Nous avons lu chaque réponse avec une limite de 512 Kio et appliqué le seuil de 128 Kio aux octets reçus.
| Modèle | Limite de sortie demandée | HTTP 200 | Corps mesurés au-dessus de 128 Kio | Contrôles de réponse réussis | Plus grand corps lu (octets) |
|---|---|---|---|---|---|
| Hy4 | 8,192 | 4/4 | 0/4 | 3/4 | 68,410 |
| DeepSeek V4.1 Flash (1017) | 8,192 | 4/4 | 0/4 | 4/4 | 3,595 |
| Hy4 | 16,384 | 3/4 | 0/3 | 3/4 | 47,934 |
| DeepSeek V4.1 Flash (1017) | 16,384 | 4/4 | 0/4 | 4/4 | 4,127 |
Les quatre cas suivent le même schéma d’événements et la comparaison initiale ne comportait qu’une tentative par configuration. Sur l’exécution initiale et tous les tests complémentaires, 65 requêtes sur 67 ont produit un corps mesurable. Le plus volumineux faisait 89,739 octets, sous le seuil client de 128 Kio (131,072 octets). Les deux autres requêtes ont expiré avant la réception des en-têtes pour le cas 3 à 16,384 tokens. L’une utilisait un effort moyen lors de l’exécution initiale, l’autre un effort faible dans le lot ultérieur. Elles sont toutes deux comptabilisées dans les dénominateurs des contrôles de réponse.
Qu’avons-nous demandé au modèle ?
Chaque cas contient 72 événements fictifs de services. Tout fonctionne normalement, à l’exception de deux réponses HTTP 503 provenant d’un même service, d’un signal tel qu’un retard dans la file d’attente, puis d’une reprise confirmée. Le prompt demande un objet JSON contenant un résumé en anglais, un résumé en chinois, le service affecté, un score de gravité, une brève explication et les trois ID d’événements justificatifs. Il demande de mentionner le signal observé sans le présenter comme la cause.
Un résumé simple pourrait seulement demander de décrire l’incident en une phrase. Ici, le modèle doit aussi identifier le service affecté parmi des événements courants, appliquer une règle de notation explicite et renvoyer des références vérifiables par un programme. Les cas partagent un même modèle, ce qui permet de connaître à l’avance le service, le score et les ID d’événements attendus. Les contrôles automatisés vérifient la structure et ces valeurs exactes. Ils exigent également des résumés non vides et une explication de 480 caractères au maximum. Ils n’évaluent pas la qualité de la traduction et ne vérifient pas indépendamment le texte rédigé.
Enregistrez cet exemple sous replay.py et définissez SYNTHORAI_API_KEY. Exécutez python replay.py --case 2 --effort none --max-tokens 16384 pour le cas du catalogue. Utilisez --effort low, medium ou high pour tester avec raisonnement, et --max-tokens 8192 pour tester la limite inférieure. Le script affiche la taille du corps, le motif de fin, l’utilisation déclarée, l’état d’achèvement de la génération et le résultat des contrôles de champs. Le résultat global n’est considéré comme réussi que si le motif de fin est stop et que les champs passent les contrôles.
"""Replay a fictional operations incident and evaluate two reader limits."""
import argparse
import json
import os
import time
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
LOW_LIMIT = 128 * 1024
HIGH_LIMIT = 512 * 1024
SERVICES = ("checkout", "catalog", "notifications", "search")
def fixture(index):
service = SERVICES[index]
signals = ("queue delay", "connection pool saturation", "cache miss spike", "disk latency")
signal = signals[index]
events = []
for i in range(1, 73):
if i in (31, 36):
detail = f"{service} returned HTTP 503. Observed {signal}."
name = service
elif i == 49:
detail = f"{service} returned HTTP 200. Recovery confirmed."
name = service
else:
name = SERVICES[(index + i) % 4]
detail = "Routine operation. HTTP 200. No incident evidence."
events.append({"id": i, "minute": i, "service": name, "detail": detail})
prompt = (
"Review these fictional operations events. Return one JSON object with "
"summary_en, summary_zh, affected_service, severity, risk_reason, and evidence_ids. "
"Severity is 3 when a service has at least two observed HTTP 503 events followed "
"by confirmed recovery. Identify that service. Cite precisely the two failure "
"events and the recovery event in order. Write one sentence in each summary and "
"explain the rating in at most 480 characters. Mention the observed signal but "
"do not claim it caused the failures. Events: " + json.dumps(events)
)
return prompt, service
def probe(index, effort, cap):
model = "hy4"
prompt, service = fixture(index)
payload = {"model": model, "max_tokens": cap, "reasoning_effort": effort,
"messages": [{"role": "user", "content": prompt}]}
request = Request(
"https://synthorai.io/v1/chat/completions", json.dumps(payload).encode(),
{"Authorization": "Bearer " + os.environ["SYNTHORAI_API_KEY"],
"Content-Type": "application/json", "Accept-Encoding": "identity"},
)
row = {"model": model, "cap": cap, "case": index + 1, "effort": effort}
started = time.monotonic()
try:
with urlopen(request, timeout=120) as response:
row["status"] = response.status
raw = response.read(HIGH_LIMIT + 1)
row.update(bytes_read=len(raw), exceeds_128_kib=len(raw) > LOW_LIMIT,
exceeds_512_kib=len(raw) > HIGH_LIMIT)
if len(raw) <= HIGH_LIMIT:
data = json.loads(raw)
choice = data["choices"][0]
content = choice["message"].get("content")
usage = data.get("usage") or {}
row.update(finish_reason=choice.get("finish_reason"),
generation_completed=choice.get("finish_reason") == "stop",
content_chars=len(content or ""),
reasoning_tokens=(usage.get("completion_tokens_details") or {}).get("reasoning_tokens"),
completion_tokens=usage.get("completion_tokens"), cost_usd=usage.get("cost"))
try:
answer = json.loads(content or "")
row["valid_json"] = isinstance(answer, dict)
row["passes_field_checks"] = (
row["valid_json"] and answer.get("severity") == 3
and answer.get("affected_service") == service
and answer.get("evidence_ids") == [31, 36, 49]
and all(isinstance(answer.get(k), str) and bool(answer[k].strip())
for k in ("summary_en", "summary_zh", "risk_reason"))
and len(answer["risk_reason"]) <= 480
)
except ValueError:
row.update(valid_json=False, passes_field_checks=False)
except HTTPError as exc:
row["status"] = exc.code
except (URLError, OSError, ValueError, KeyError, IndexError) as exc:
row["error"] = type(exc).__name__
row["success"] = (
row.get("generation_completed") is True and row.get("passes_field_checks") is True
)
row["seconds"] = round(time.monotonic() - started, 2)
return row
parser = argparse.ArgumentParser()
parser.add_argument("--case", type=int, choices=range(1, len(SERVICES) + 1), default=1)
parser.add_argument("--effort", choices=("none", "low", "medium", "high"), default="medium")
parser.add_argument("--max-tokens", type=int, choices=(8192, 16384), default=16384)
args = parser.parse_args()
print(json.dumps(probe(args.case - 1, args.effort, args.max_tokens), indent=2))
FAQ
Que se passe-t-il lorsqu’une réponse dépasse la limite client de 128 Kio ?
Le client peut interrompre la lecture avant de pouvoir analyser la réponse finale. Dans cette expérience avec Hy4, 128 Kio correspondait au seuil d’octets du lecteur. La limite distincte de tokens de sortie contrôlait la génération.
Comment vérifier que Hy4 a respecté reasoning_effort none ?
Consultez usage.completion_tokens_details.reasoning_tokens. Hy4 a indiqué zéro pour les 12 requêtes envoyées avec reasoning_effort: "none" via Synthorai. Si le champ est absent, la réponse ne fournit aucun décompte permettant de le vérifier.