Perché Tencent Hy4 esaurisce i token prima di rispondere
Indice
- Che cosa è successo nel riepilogo dell’incidente del catalogo?
- Come si diagnostica una risposta vuota?
- Che cosa controllano i parametri di reasoning e output di Hy4?
- Il caso 2 è stato troncato di nuovo a 8,192 token?
- Come si sono comportate le quattro impostazioni di reasoning?
- Come deve gestire il chiamante questo errore di Hy4?
- Come hanno gestito gli stessi casi Hy4 e DeepSeek?
- Che cosa abbiamo chiesto al modello?
- Domande frequenti
- Che cosa succede quando una risposta supera il limite del client di 128 KiB?
- Come verifico se Hy4 ha rispettato reasoning_effort none?
Tencent Hy4 ha restituito HTTP 200 con una risposta finale vuota durante il riepilogo di un incidente sintetico. Ha dichiarato 8,192 token di reasoning, esattamente il limite di output richiesto. Su questa route API, il reasoning e la risposta finale condividono lo stesso budget. Un client che controlla solo lo stato HTTP può scambiare una risposta che ha esaurito i token per un riepilogo completato.
TL;DR
- Hy4 ha restituito HTTP 200 con una risposta finale vuota dopo aver usato tutti gli 8,192 token di output per il reasoning.
- La risposta si è conclusa con
finish_reason: "length"e misurava 68,410 byte, sotto la soglia del client di 128 KiB. - Su quattro incidenti basati su regole,
noneha mantenuto i fatti principali in entrambe le lingue e ha ridotto la dimensione mediana del body della risposta da 51,780 a 1,467 byte rispetto amedium.
Che cosa è successo nel riepilogo dell’incidente del catalogo?
Abbiamo chiesto a Hy4 di riepilogare un incidente fittizio in inglese e cinese, assegnare un livello di gravità secondo una regola prestabilita e citare in JSON gli eventi di errore e ripristino. Nel caso del catalogo con effort medio, l’API ha restituito HTTP 200 e finish_reason: "length". Ha dichiarato 8,192 token di reasoning a fronte di un limite di output di 8,192 token, mentre message.content era vuoto. La risposta completa misurava 68,410 byte, sotto la soglia del client di 128 KiB.
Come si diagnostica una risposta vuota?
| Che cosa vede il client | Che cosa controllare |
|---|---|
| La richiesta va in timeout prima degli header | Registra l’eccezione di trasporto e il tempo trascorso. Il client non dispone né dello stato né del body della risposta da esaminare. |
| Il reader raggiunge il limite di byte | Registra il limite e i byte ricevuti. Il client potrebbe essersi fermato prima di poter eseguire il parsing della risposta. |
| La risposta completa ha un contenuto finale vuoto o parziale | Controlla finish_reason, message.content e usage.completion_tokens_details.reasoning_tokens. Nel caso del catalogo, length e un numero di token di reasoning uguale al limite di output indicano il punto in cui si è interrotta la generazione. |
Verifica che la generazione sia terminata prima di inoltrare la risposta ai sistemi downstream. Anche se il contenuto finale viene interpretato correttamente come JSON e i campi sembrano validi, un valore length indica che la generazione ha raggiunto un limite. Una volta completata la generazione, valida la risposta finale rispetto all’input.
Conserva insieme nei log delle richieste lo stato originale della risposta e il finish reason. Se entrambi i casi vengono ridotti a un generico errore di “JSON non valido”, una risposta mancante e una risposta completa con un campo errato risultano identiche nel monitoraggio. Richiedono invece analisi diverse. Nel primo caso bisogna controllare il budget e verificare se la generazione è terminata. Nel secondo vanno controllati il prompt, i valori attesi e le regole di validazione.
Che cosa controllano i parametri di reasoning e output di Hy4?
Il parametro di richiesta reasoning_effort indica il livello di ragionamento richiesto prima della risposta finale. La documentazione TokenHub di Tencent prevede due controlli per il reasoning di Hy4. Il campo thinking.type lo attiva o disattiva tramite enabled o disabled. Il reasoning è attivo per impostazione predefinita. La tabella specifica del modello indica high e no_think come valori di reasoning_effort per Hy4, con high come default. La stessa tabella riporta opzioni diverse per altri modelli. Quando sposti una richiesta tra provider, controlla la riga relativa all’esatto ID del modello. Guida di Tencent TokenHub al deep thinking
Per Synthorai Chat Completions abbiamo inviato none, low, medium e high come valori di effort richiesti. La documentazione di TokenHub descrive il proprio endpoint. Le nostre misurazioni riguardano il comportamento delle richieste Synthorai e non dimostrano come ogni valore di effort venga mappato upstream. Sulla route Synthorai testata, none ha restituito una risposta finale con zero token di reasoning dichiarati in tutte le 12 ripetizioni. Usa questa misurazione come verifica di compatibilità per la route chiamata dalla tua applicazione. Se passi a un altro endpoint o cambi l’ID del modello, ripeti una prova con input noto e verifica l’utilizzo del reasoning e il contenuto finale prima del rollout.
Il limite di output è un controllo separato. Abbiamo inviato max_tokens per impostare il tetto richiesto per la generazione. Se il modello raggiunge il limite prima di iniziare la risposta finale, anche un prompt che richiede un oggetto JSON breve può produrre un contenuto vuoto. Nella guida alla risoluzione dei problemi, Tencent descrive il budget condiviso tra reasoning e risposta usando Hy3 come esempio. La misurazione di Hy4 mostra lo stesso tipo di errore sulla route Synthorai testata, con tutti gli 8,192 token dichiarati come reasoning. Guida alle API Hy di Tencent
Il budget di output limita la generazione. Il limite di byte del client stabilisce invece la quantità di body HTTP letta, inclusi gli eventuali campi di reasoning. Configura i due limiti separatamente, mantenendo invariati input e impostazione del reasoning.
Il caso 2 è stato troncato di nuovo a 8,192 token?
Abbiamo rieseguito tre volte il caso del catalogo con Hy4, effort medio e un limite di 8,192 token. Tutte e tre le esecuzioni hanno superato i controlli e dichiarato tra 5,106 e 7,155 token di reasoning. Per il confronto con 16,384 token abbiamo riutilizzato le tre richieste del catalogo con effort medio dell’esperimento a quattro impostazioni descritto sotto. Tutte e tre hanno superato i controlli. Le richieste con 8,192 token sono state eseguite in seguito. La prima richiesta con 8,192 token era stata troncata, mentre tutte e tre le richieste successive con lo stesso limite sono terminate. Queste ripetizioni coprono un solo input e i due limiti sono stati testati in sequenza. Non è ancora chiaro quale effetto abbia l’aumento del limite sulla frequenza dei troncamenti.
Come si sono comportate le quattro impostazioni di reasoning?
Abbiamo rieseguito gli stessi quattro casi su Hy4 tramite Synthorai, tre volte per ogni combinazione di caso ed effort richiesto. Il prompt, il limite di 16,384 token, il limite di lettura di 512 KiB e il timeout del socket client di 120 secondi sono rimasti invariati. Abbiamo testato insieme medium e none, quindi abbiamo eseguito low e high in un batch successivo.
| Effort richiesto | Controlli dei campi JSON superati | Token di reasoning dichiarati | Dimensione mediana misurata del body |
|---|---|---|---|
none | 12/12 | Sempre 0 | 1,467 byte |
low | 11/12 | Da 2,575 a 11,181 | 42,047 byte |
medium | 12/12 | Da 2,989 a 9,317 | 51,780 byte |
high | 12/12 | Da 2,911 a 9,987 | 58,369.5 byte |
L’intervallo di token e la mediana del body del gruppo low si basano sulle sue 11 risposte misurate. Gli altri tre gruppi hanno 12 misurazioni ciascuno. Gli intervalli di token osservati per le richieste inviate con low, medium e high si sovrappongono. Una risposta low ha dichiarato 11,181 token di reasoning, più di qualsiasi risposta medium misurata in questo test.
Per ogni risposta completata abbiamo confrontato con gli eventi di origine entrambi i riepiloghi e la spiegazione del rischio. In entrambe le lingue, i riepiloghi hanno mantenuto il servizio interessato, i due eventi HTTP 503 e il ripristino confermato. Le spiegazioni hanno applicato la regola di gravità fornita e descritto il segnale associato come un’osservazione. Questi controlli coprono la fedeltà ai fatti su quattro casi basati su un template comune e una regola di gravità esplicita.
Come deve gestire il chiamante questo errore di Hy4?
Consideriamo un worker che pubblica un riepilogo in inglese e cinese alla chiusura dell’incidente del catalogo. Dispone già degli eventi originali, quindi registra i fatti verificabili via codice. Il servizio catalogo ha restituito due risposte HTTP 503 negli eventi 31 e 36, mentre l’evento 49 ha confermato il ripristino. La regola di calcolo assegna gravità 3. Questi valori forniscono al worker sia un criterio di accettazione sia dati da restituire in caso di errore nella generazione del riepilogo.
- Accetta solo un riepilogo completo e validato. Il worker legge la risposta entro il limite di byte configurato e verifica che il finish sia
stopprima di esaminare il JSON finale. Per poter pubblicare, l’oggetto deve indicare il servizio catalogo, riportare gravità 3 e citare[31, 36, 49]in quest’ordine. Durante il rollout, valida entrambe le lingue rispetto agli stessi eventi. Ogni riepilogo deve riportare gli errori e il ripristino confermato. La spiegazione del rischio può citare la saturazione osservata del connection pool, ma qualsiasi nesso causale richiede ulteriori prove. Un finishlengthnon supera i criteri di accettazione, anche se il contenuto parziale viene interpretato correttamente. - Esegui un solo retry con limiti definiti in caso di risposta vuota. In questo esempio, la prima richiesta usa
mediume un limite di 8,192 token. Se restituiscelength, contenuto vuoto e un utilizzo del reasoning pari al limite, il worker può riprovare connone, purché questa impostazione abbia superato i test sul workload effettivo. Mantieni invariati il prompt e il limite di token. Il confronto connoneè stato eseguito con 16,384 token, quindi valida il retry a 8,192 prima di adottarlo. Conserva l’errore originale nel log dei tentativi e applica al retry gli stessi criteri di accettazione. Il timeout del socket di 120 secondi nello script di esempio vale per una singola chiamata. Il worker deve eseguire il retry solo se il tempo residuo consente di completarlo entro la deadline complessiva del job. - Restituisci un fallback esplicito se anche il retry fallisce o il tempo scade. Imposta lo stato del riepilogo su
failedopending_review, a seconda che sia prevista una revisione manuale, e lascia vuoti entrambi i campi del riepilogo generato. Mantieni disponibili i metadati verificati dell’incidente e gli ID degli eventi originali, così il chiamante può comunque consultare le prove. Registra separatamente l’esito del primo tentativo e quello del retry. Un retry riuscito può fornire il riepilogo, mentre la risposta vuota originale resta visibile nel monitoraggio.
Se mantieni il reasoning per workload che richiedono valutazioni, dimensiona il budget di output in base all’utilizzo misurato su input rappresentativi, includendo sia i token di reasoning sia quelli della risposta finale. Prima di impostare il limite del reader, misura separatamente le dimensioni complete dei body, perché i byte che l’applicazione deve mantenere in memoria includono anche l’envelope della risposta. Quando scegli il limite, considera il picco di concorrenza. Valuta il rollout in base alla percentuale di richieste che producono un riepilogo completo e corretto, includendo i timeout nel denominatore. Esamina separatamente l’accuratezza fattuale dei riepiloghi restituiti, verificando anche se le prove supportano le valutazioni che la regola lascia al modello.
Come hanno gestito gli stessi casi Hy4 e DeepSeek?
Abbiamo inviato ciascuno dei quattro prompt tramite Synthorai una volta per ogni combinazione di modello e limite. Sia Hy4 sia DeepSeek V4.1 Flash (1017) hanno ricevuto una richiesta con effort di reasoning medio. Abbiamo letto ogni risposta con un limite di 512 KiB e applicato la soglia di 128 KiB ai byte ricevuti.
| Modello | Limite di output richiesto | HTTP 200 | Oltre 128 KiB tra i body misurati | Controlli della risposta superati | Body più grande letto (byte) |
|---|---|---|---|---|---|
| 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 |
I quattro casi condividono lo stesso schema di eventi e il confronto iniziale ha usato un solo tentativo per configurazione. Tra l’esecuzione iniziale e tutti i follow-up, 65 richieste su 67 hanno prodotto body misurabili. Il più grande misurava 89,739 byte, sotto la soglia del client di 128 KiB (131,072 byte). Le altre due richieste sono andate in timeout prima degli header della risposta nel caso 3 con 16,384 token: una con effort medio durante l’esecuzione iniziale e una con effort basso nel batch successivo. Entrambe sono incluse nei denominatori delle richieste per i controlli della risposta.
Che cosa abbiamo chiesto al modello?
Ogni caso contiene 72 eventi fittizi relativi a servizi. Tutto funziona normalmente, a eccezione di due risposte HTTP 503 da un servizio, un segnale come un ritardo nella coda e un ripristino confermato. Il prompt richiede un singolo oggetto JSON contenente un riepilogo in inglese, uno in cinese, il servizio interessato, un livello di gravità, una breve spiegazione e gli ID dei tre eventi a supporto. Chiede al modello di citare il segnale osservato senza presentarlo come causa.
Un riepilogo semplice potrebbe limitarsi a chiedere che cosa è successo in una frase. Questo prompt richiede anche di individuare il servizio interessato tra gli eventi di routine, applicare una regola di scoring esplicita e restituire riferimenti verificabili da un programma. I casi condividono un template, quindi il servizio, il punteggio e gli ID degli eventi attesi sono noti. I controlli automatici verificano la struttura e questi valori esatti. Richiedono inoltre riepiloghi non vuoti e una spiegazione di non più di 480 caratteri. Non valutano la qualità della traduzione né verificano autonomamente il testo.
Salva questo esempio come replay.py e imposta SYNTHORAI_API_KEY. Esegui python replay.py --case 2 --effort none --max-tokens 16384 per il caso del catalogo. Usa --effort low, medium o high per testare con il reasoning e --max-tokens 8192 per provare il limite inferiore. Lo script stampa la dimensione del body, il finish reason, l’utilizzo dichiarato, lo stato di completamento della generazione e i risultati dei controlli sui campi. Il flag complessivo di successo richiede un finish stop e il superamento dei controlli sui campi.
"""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))
Domande frequenti
Che cosa succede quando una risposta supera il limite del client di 128 KiB?
Il client può interrompere la lettura della risposta prima di poter eseguire il parsing del risultato finale. In questo esperimento con Hy4, 128 KiB era la soglia in byte del reader. Il limite separato dei token di output controllava invece la generazione.
Come verifico se Hy4 ha rispettato reasoning_effort none?
Controlla usage.completion_tokens_details.reasoning_tokens. Hy4 ha dichiarato zero in tutte le 12 richieste eseguite tramite Synthorai con reasoning_effort: "none". Se il campo manca, la risposta non fornisce alcun valore con cui verificarlo.