Warum Tencent Hy4 vor der Antwort alle Tokens verbraucht
Inhalt
- Was geschah bei der Zusammenfassung des Catalog-Incidents?
- Wie diagnostiziert man eine leere Antwort?
- Was steuern die Reasoning- und Output-Parameter von Hy4?
- Wurde Fall 2 bei 8,192 Tokens erneut abgeschnitten?
- Wie unterschieden sich die vier Reasoning-Einstellungen?
- Wie sollte ein Aufrufer mit diesem Hy4-Fehler umgehen?
- Wie verarbeiteten Hy4 und DeepSeek dieselben Fälle?
- Welche Aufgabe erhielt das Modell?
- FAQ
- Was geschieht, wenn eine Response das Client-Limit von 128 KiB überschreitet?
- Wie erkenne ich, ob Hy4 reasoning_effort none berücksichtigt hat?
Tencent Hy4 lieferte für die Zusammenfassung eines synthetischen Incidents HTTP 200, aber keine finale Antwort. Als Reasoning-Verbrauch meldete das Modell 8,192 Tokens, genau das konfigurierte Output-Limit. Bei dieser API-Route teilen sich Reasoning und finale Antwort dasselbe Budget. Prüft ein Client nur den HTTP-Status, kann er eine wegen Tokenmangels abgebrochene Response für eine vollständige Zusammenfassung halten.
TL;DR
- Hy4 lieferte HTTP 200 mit leerer finaler Antwort, nachdem alle 8,192 Output-Tokens für Reasoning verbraucht waren.
- Die Response endete mit
finish_reason: "length"und war 68,410 Bytes groß. Damit blieb sie unter dem Client-Limit von 128 KiB. - Bei vier regelbasierten Incidents behielt
nonedie wesentlichen Fakten in beiden Sprachen bei und senkte die mediane Response-Größe gegenübermediumvon 51,780 auf 1,467 Bytes.
Was geschah bei der Zusammenfassung des Catalog-Incidents?
Wir ließen Hy4 einen fiktiven Service-Incident auf Englisch und Chinesisch zusammenfassen, den Schweregrad anhand einer festen Regel bewerten und die Fehler- sowie Recovery-Events als JSON angeben. Beim Catalog-Fall mit mittlerem Reasoning-Aufwand lieferte die API HTTP 200 und finish_reason: "length". Sie meldete 8,192 Reasoning-Tokens bei einem Output-Limit von 8,192 Tokens. message.content war leer. Die vollständige Response war 68,410 Bytes groß und lag damit unter dem Client-Limit von 128 KiB.
Wie diagnostiziert man eine leere Antwort?
| Was der Client sieht | Was zu prüfen ist |
|---|---|
| Der Request läuft vor dem Empfang der Header in ein Timeout | Transportfehler und verstrichene Zeit protokollieren. Der Client hat weder Status noch Response-Body zur Prüfung. |
| Der Reader erreicht sein Byte-Limit | Limit und empfangene Bytes protokollieren. Möglicherweise hat der Client abgebrochen, bevor er die Antwort parsen konnte. |
| Die vollständige Response enthält keinen oder nur einen Teil des finalen Inhalts | finish_reason, message.content und usage.completion_tokens_details.reasoning_tokens prüfen. Beim Catalog-Fall zeigen length und eine dem Output-Limit entsprechende Anzahl an Reasoning-Tokens, an welcher Stelle die Generierung endete. |
Prüft vor der Weitergabe der Antwort, ob die Generierung vollständig abgeschlossen wurde. Auch wenn sich der finale Inhalt als JSON parsen lässt und die Felder korrekt aussehen, bedeutet length, dass die Generierung ein Limit erreicht hat. Nach Abschluss der Generierung muss die finale Antwort gegen die Eingabe validiert werden.
Speichert den ursprünglichen Response-Status und den Finish-Reason gemeinsam im Request-Log. Werden beide Fälle auf einen generischen Fehler wie „ungültiges JSON“ reduziert, sehen eine fehlende Antwort und eine vollständige Antwort mit einem falschen Feld im Monitoring gleich aus. Die Fehleranalyse unterscheidet sich jedoch. Im ersten Fall sind Budget und Abschluss der Generierung zu prüfen. Im zweiten Fall geht es um Prompt, erwartete Werte und Validierungsregeln.
Was steuern die Reasoning- und Output-Parameter von Hy4?
Der Anfrageparameter reasoning_effort legt fest, mit welcher Intensität das Modell vor der endgültigen Antwort nachdenken soll. Die TokenHub-Dokumentation von Tencent beschreibt für Hy4 zwei Steuerelemente für das Reasoning. Das Feld thinking.type schaltet Reasoning mit enabled oder disabled ein oder aus. Standardmäßig ist es aktiviert. In der modellspezifischen Tabelle sind für reasoning_effort bei Hy4 die Werte high und no_think aufgeführt, wobei high der Standardwert ist. Für andere Modelle nennt dieselbe Tabelle andere Optionen. Prüft beim Wechsel eines Requests zwischen Providern immer die Zeile für die konkrete Modell-ID. Leitfaden von Tencent TokenHub zu Deep Thinking
Für Synthorai Chat Completions sendeten wir none, low, medium und high als gewünschte Effort-Werte. Die TokenHub-Dokumentation beschreibt den eigenen Endpoint. Unsere Messungen zeigen das Verhalten der Synthorai-Requests, nicht das Upstream-Mapping aller Effort-Werte. Auf der getesteten Synthorai-Route lieferte none bei allen 12 Wiederholungen eine finale Antwort und meldete null Reasoning-Tokens. Diese Response-Messung dient als Kompatibilitätsprüfung für die Route, die eure Anwendung tatsächlich aufruft. Bei einem Wechsel zu einem anderen Endpoint oder einer anderen Modell-ID solltet ihr einen Test mit bekannter Eingabe wiederholen und vor dem Rollout Reasoning-Verbrauch und finalen Inhalt prüfen.
Das Output-Limit wird separat gesteuert. Mit max_tokens legten wir die gewünschte Obergrenze für die Generierung fest. Erreicht das Modell diese Grenze, bevor es mit der finalen Antwort beginnt, kann selbst ein Prompt für ein kurzes JSON-Objekt leeren Inhalt zurückgeben. Der Troubleshooting-Leitfaden von Tencent beschreibt das gemeinsame Budget für Reasoning und Antwort am Beispiel von Hy3. Unsere Hy4-Messung weist dasselbe Fehlermuster auf der getesteten Synthorai-Route nach: Alle 8,192 Tokens wurden als Reasoning gemeldet. Leitfaden von Tencent zur Hy API
Das Output-Budget begrenzt die Generierung. Das Byte-Limit des Clients bestimmt, wie viel vom HTTP-Body er liest, einschließlich möglicher Reasoning-Felder. Beide Limits müssen unabhängig voneinander und mit derselben Eingabe sowie Reasoning-Einstellung abgestimmt werden.
Wurde Fall 2 bei 8,192 Tokens erneut abgeschnitten?
Wir spielten den Catalog-Fall mit Hy4 und mittlerem Reasoning-Aufwand dreimal bei 8,192 Tokens ab. Alle drei Durchläufe waren erfolgreich und meldeten 5,106 bis 7,155 Reasoning-Tokens. Für den Vergleich mit 16,384 Tokens verwendeten wir erneut die drei Catalog-Requests mit mittlerem Aufwand aus dem Experiment mit vier Einstellungen weiter unten. Alle drei waren erfolgreich. Die Requests mit 8,192 Tokens liefen danach. Der erste Request mit 8,192 Tokens wurde abgeschnitten, die drei späteren Requests mit demselben Limit wurden vollständig abgeschlossen. Diese Wiederholungen decken eine Eingabe ab, wobei die beiden Limits nacheinander getestet wurden. Ob ein höheres Limit die Abbruchrate senkt, bleibt unklar.
Wie unterschieden sich die vier Reasoning-Einstellungen?
Wir führten dieselben vier Fälle mit Hy4 über Synthorai jeweils dreimal pro Fall und gewünschtem Aufwand aus. Prompt, Token-Limit von 16,384, Read-Limit von 512 KiB und Client-Socket-Timeout von 120 Sekunden blieben unverändert. Zuerst testeten wir medium und none gemeinsam, anschließend low und high in einem späteren Batch.
| Gewünschter Aufwand | JSON-Feldprüfungen bestanden | Gemeldete Reasoning-Tokens | Median des gemessenen Response-Bodys |
|---|---|---|---|
none | 12/12 | durchgehend 0 | 1,467 Bytes |
low | 11/12 | 2,575 bis 11,181 | 42,047 Bytes |
medium | 12/12 | 2,989 bis 9,317 | 51,780 Bytes |
high | 12/12 | 2,911 bis 9,987 | 58,369.5 Bytes |
Token-Spanne und Body-Median der Gruppe low basieren auf den 11 gemessenen Responses. Für jede der anderen drei Gruppen liegen 12 Messungen vor. Die beobachteten Token-Spannen der mit low, medium und high gesendeten Requests überschneiden sich. Eine low-Response meldete 11,181 Reasoning-Tokens, mehr als jede gemessene medium-Response in diesem Test.
Bei jeder vollständigen Response prüften wir beide Zusammenfassungen und die Risikobegründung anhand der Quell-Events. Die Zusammenfassungen nannten in beiden Sprachen den betroffenen Service, die beiden HTTP-503-Events und die bestätigte Recovery. Die Begründungen wandten die vorgegebene Schweregradregel an und beschrieben das zusätzliche Signal als Beobachtung. Diese Prüfungen decken die Faktentreue für vier Fälle mit gemeinsamem Template und expliziter Schweregradregel ab.
Wie sollte ein Aufrufer mit diesem Hy4-Fehler umgehen?
Als Beispiel dient ein Worker, der beim Abschluss des Catalog-Incidents eine englische und eine chinesische Zusammenfassung veröffentlicht. Da ihm die Quell-Events bereits vorliegen, zeichnet er die programmatisch prüfbaren Fakten auf. Der Catalog-Service lieferte bei den Events 31 und 36 jeweils HTTP 503. Event 49 bestätigte die Recovery. Die Bewertungsregel ergibt Schweregrad 3. Damit kann der Worker sowohl die Modellantwort prüfen als auch eine verwertbare Rückgabe erzeugen, falls die Zusammenfassung fehlschlägt.
- Nur vollständig generierte und validierte Zusammenfassungen akzeptieren. Der Worker liest die Response innerhalb seines konfigurierten Byte-Limits und prüft auf den Finish-Reason
stop, bevor er das finale JSON auswertet. Für eine Veröffentlichung muss das Objekt den Catalog-Service nennen, Schweregrad 3 angeben und[31, 36, 49]in dieser Reihenfolge referenzieren. Während des Rollouts sind beide Sprachen anhand derselben Event-Fakten zu validieren. Jede Zusammenfassung muss die Fehler und die bestätigte Recovery wiedergeben. Die Risikobegründung darf die beobachtete Sättigung des Connection-Pools erwähnen. Eine Kausalitätsaussage erfordert zusätzliche Belege. Der Finish-Reasonlengthbesteht die Prüfung nicht, selbst wenn sich der Teilinhalt zufällig parsen lässt. - Bei leerer Response genau einen begrenzten Retry ausführen. In diesem Beispiel nutzt der erste Request
mediumund ein Token-Limit von 8,192. Liefert erlengthmit leerem Inhalt und einem Reasoning-Verbrauch in Höhe des Limits, kann der Worker den Request mitnonewiederholen, sofern diese Einstellung die Tests mit der eigenen Workload bestanden hat. Prompt und Token-Limit bleiben dabei unverändert. Unser Vergleich mitnoneverwendete 16,384 Tokens. Ein Retry mit 8,192 muss daher vor der Einführung separat validiert werden. Der ursprüngliche Fehler bleibt im Attempt-Log erhalten. Für den Retry gelten dieselben Akzeptanzprüfungen. Das Socket-Timeout des Beispielskripts von 120 Sekunden gilt jeweils für einen einzelnen Aufruf. Der Worker darf den Retry nur starten, wenn die verbleibende Zeit für einen Abschluss innerhalb der gesamten Job-Deadline ausreicht. - Bei fehlgeschlagenem Retry oder abgelaufener Zeit einen expliziten Fallback zurückgeben. Setzt den Status der Zusammenfassung auf
failedoderpending_review, je nachdem, ob eine manuelle Prüfung vorgesehen ist, und lasst beide generierten Zusammenfassungsfelder leer. Die verifizierten Incident-Metadaten und IDs der Quell-Events müssen verfügbar bleiben, damit der Aufrufer weiterhin auf die Belege zugreifen kann. Die Ergebnisse des ersten Versuchs und des Retries sind getrennt zu speichern. Ein erfolgreicher Retry kann eine Zusammenfassung liefern, während die ursprüngliche leere Response im Monitoring sichtbar bleibt.
Bleibt Reasoning für Workloads aktiviert, die eine Bewertung erfordern, sollte das Output-Budget anhand gemessener Completion-Nutzung repräsentativer Eingaben festgelegt werden. Dabei zählen Reasoning- und Final-Answer-Tokens. Messt die vollständige Body-Größe separat, bevor ihr das Reader-Limit setzt, denn die Anwendung muss neben dem Inhalt auch den Response-Envelope puffern. Berücksichtigt bei der Wahl des Limits die maximale Parallelität. Bewertet den Rollout anhand des Anteils von Requests, die eine vollständige und korrekte Zusammenfassung liefern. Timeouts gehören in den Nenner. Prüft die faktische Qualität der zurückgegebenen Zusammenfassungen separat. Dazu gehört auch, ob die Belege alle Bewertungen stützen, die nicht bereits durch die Bewertungsregel festgelegt sind.
Wie verarbeiteten Hy4 und DeepSeek dieselben Fälle?
Wir sendeten jeden der vier Prompts über Synthorai jeweils einmal pro Modell und Limit. Hy4 und DeepSeek V4.1 Flash (1017) erhielten beide einen Request mit mittlerem Reasoning-Aufwand. Jede Response wurde mit einem Limit von 512 KiB gelesen. Auf die empfangenen Bytes wandten wir anschließend den Schwellenwert von 128 KiB an.
| Modell | Gewünschtes Output-Limit | HTTP 200 | Über 128 KiB bei gemessenen Bodys | Antwortprüfungen bestanden | Größter gelesener Body (Bytes) |
|---|---|---|---|---|---|
| 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 |
Die vier Fälle verwenden dasselbe Event-Muster. Im ersten Vergleich gab es pro Konfiguration nur einen Versuch. Über den ersten Durchlauf und alle Folgetests hinweg lieferten 65 von 67 Requests messbare Bodys. Der größte war 89,739 Bytes groß und lag damit unter dem Client-Limit von 128 KiB (131,072 Bytes). Bei den beiden übrigen Requests trat vor dem Empfang der Response-Header ein Timeout auf. Beide betrafen Fall 3 mit 16,384 Tokens, einer mit mittlerem Aufwand im ersten Durchlauf und einer mit niedrigem Aufwand im späteren Batch. Beide zählen bei den Antwortprüfungen zum Request-Nenner.
Welche Aufgabe erhielt das Modell?
Jeder Fall enthält 72 fiktive Service-Events. Bis auf zwei HTTP-503-Responses eines einzelnen Service, ein Signal wie Queue-Verzögerung und eine bestätigte Recovery läuft alles normal. Der Prompt fordert ein JSON-Objekt mit einer englischen Zusammenfassung, einer chinesischen Zusammenfassung, dem betroffenen Service, einem Schweregrad, einer kurzen Begründung und den drei zugehörigen Event-IDs. Das Modell soll das beobachtete Signal erwähnen, es aber nicht als Ursache darstellen.
Eine einfache Zusammenfassung könnte lediglich in einem Satz beschreiben, was passiert ist. Dieser Prompt verlangt zusätzlich, den betroffenen Service zwischen Routine-Events zu identifizieren, eine explizite Bewertungsregel anzuwenden und programmatisch prüfbare Referenzen zurückzugeben. Die Fälle verwenden ein gemeinsames Template, sodass Service, Bewertung und Event-IDs im Voraus bekannt sind. Die automatisierten Prüfungen decken Struktur und exakte Werte ab. Zusätzlich verlangen sie nicht leere Zusammenfassungen und eine höchstens 480 Zeichen lange Begründung. Die Qualität der Übersetzung und die Prosa werden weder bewertet noch unabhängig geprüft.
Speichert dieses Beispiel als replay.py und setzt SYNTHORAI_API_KEY. Führt für den Catalog-Fall python replay.py --case 2 --effort none --max-tokens 16384 aus. Mit --effort low, medium oder high testet ihr mit Reasoning, mit --max-tokens 8192 das niedrigere Limit. Das Skript gibt Body-Größe, Finish-Reason, gemeldete Nutzung, Abschlussstatus der Generierung und Ergebnisse der Feldprüfungen aus. Das Gesamtergebnis gilt nur dann als erfolgreich, wenn der Finish-Reason stop lautet und alle Feldprüfungen bestanden werden.
"""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
Was geschieht, wenn eine Response das Client-Limit von 128 KiB überschreitet?
Der Client kann das Lesen der Response abbrechen, bevor er die finale Antwort parsen kann. In diesem Hy4-Experiment waren 128 KiB der Byte-Schwellenwert des Readers. Das davon unabhängige Output-Token-Limit steuerte die Generierung.
Wie erkenne ich, ob Hy4 reasoning_effort none berücksichtigt hat?
Prüft usage.completion_tokens_details.reasoning_tokens. Hy4 meldete bei allen 12 über Synthorai mit reasoning_effort: "none" gesendeten Requests null. Fehlt das Feld, enthält die Response keinen überprüfbaren Wert.