Por que o Tencent Hy4 esgota os tokens antes de responder
Conteúdo
- O que aconteceu no resumo do incidente do catálogo?
- Como diagnosticar uma resposta vazia?
- O que os parâmetros de raciocínio e saída do Hy4 controlam?
- O caso 2 voltou a ser truncado em 8,192 tokens?
- Como as quatro configurações de raciocínio se compararam?
- Como o cliente deve tratar essa falha do Hy4?
- Como Hy4 e DeepSeek processaram os mesmos casos?
- O que pedimos ao modelo?
- Perguntas frequentes
- O que acontece quando uma resposta ultrapassa o limite de 128 KiB do cliente?
- Como saber se o Hy4 respeitou reasoning_effort none?
O Tencent Hy4 retornou HTTP 200, mas sem resposta final, ao resumir um incidente sintético. O uso informado foi de 8,192 tokens de raciocínio, exatamente o limite de saída solicitado. Nessa rota da API, o raciocínio e a resposta final compartilham o mesmo orçamento. Se o cliente verificar apenas o status HTTP, poderá considerar concluído um resumo que, na verdade, esgotou os tokens.
TL;DR
- O Hy4 retornou HTTP 200 sem resposta final após usar todos os 8,192 tokens de saída no raciocínio.
- A resposta terminou com
finish_reason: "length"e tinha 68,410 bytes, abaixo do limite de 128 KiB do cliente. - Em quatro incidentes baseados em regras,
nonepreservou os fatos principais nos dois idiomas e reduziu o corpo mediano da resposta de 51,780 para 1,467 bytes em comparação commedium.
O que aconteceu no resumo do incidente do catálogo?
Pedimos ao Hy4 que resumisse um incidente fictício de serviço em inglês e chinês, calculasse a gravidade com uma regra fixa e citasse em JSON os eventos de falha e recuperação. No caso do catálogo, com esforço médio, a API retornou HTTP 200 e finish_reason: "length". Ela informou 8,192 tokens de raciocínio para um limite de saída de 8,192 tokens, e message.content veio vazio. A resposta completa tinha 68,410 bytes, abaixo do limite de 128 KiB do nosso cliente.
Como diagnosticar uma resposta vazia?
| O que o cliente observa | O que verificar |
|---|---|
| A requisição expira antes dos headers | Registre a exceção de transporte e o tempo decorrido. O cliente não recebeu status nem corpo para analisar. |
| O leitor atinge o limite de bytes | Registre o limite e o total de bytes recebidos. O cliente pode ter interrompido a leitura antes de conseguir interpretar a resposta. |
| A resposta completa contém conteúdo final vazio ou parcial | Verifique finish_reason, message.content e usage.completion_tokens_details.reasoning_tokens. No caso do catálogo, length e uma contagem de raciocínio igual ao limite de saída mostram em que ponto a geração parou. |
Confirme que a geração terminou antes de encaminhar a resposta. Mesmo que o conteúdo final seja um JSON válido e os campos pareçam corretos, um encerramento com length indica que a geração atingiu um limite. Quando a geração terminar, valide a resposta final contra a entrada.
Mantenha juntos nos logs da requisição o status original da resposta e o motivo do encerramento. Se os dois casos forem reduzidos a um erro genérico de “JSON inválido”, o monitoramento não conseguirá distinguir uma resposta ausente de uma resposta concluída com um campo incorreto. A investigação é diferente em cada caso. No primeiro, é preciso verificar o orçamento e se a geração terminou. No segundo, o prompt, os valores esperados e as regras de validação.
O que os parâmetros de raciocínio e saída do Hy4 controlam?
O parâmetro de solicitação reasoning_effort indica o nível de raciocínio solicitado antes da resposta final. A documentação do TokenHub da Tencent oferece dois controles de raciocínio para o Hy4. O campo thinking.type ativa ou desativa o raciocínio com enabled ou disabled. Por padrão, ele fica ativado. A tabela específica do modelo lista high e no_think como opções de reasoning_effort do Hy4, com high como padrão. A mesma tabela mostra opções diferentes para outros modelos. Ao transferir uma requisição entre provedores, consulte a linha correspondente ao ID exato do modelo. Guia de raciocínio avançado do Tencent TokenHub
No Chat Completions da Synthorai, enviamos none, low, medium e high como valores de esforço. A documentação do TokenHub descreve o endpoint próprio da plataforma. Nossas medições registram o comportamento das requisições feitas à Synthorai, mas não determinam como cada nível é mapeado no provedor upstream. Na rota da Synthorai testada, none retornou uma resposta final com zero tokens de raciocínio informados nas 12 repetições. Use essa medição como teste de compatibilidade para a rota chamada pela sua aplicação. Se trocar de endpoint ou alterar o ID do modelo, repita um teste com entrada conhecida e confirme o uso de raciocínio e o conteúdo final antes de implantar a mudança.
O limite de saída é um controle separado. Enviamos max_tokens para definir o teto solicitado para a geração. Se o modelo atingir esse teto antes de começar a resposta final, até um prompt que peça um JSON curto poderá retornar conteúdo vazio. No exemplo do Hy3, o guia de solução de problemas da Tencent descreve o orçamento compartilhado entre raciocínio e resposta. A medição do Hy4 mostra o mesmo padrão de falha na rota da Synthorai testada, com todos os 8,192 tokens informados como raciocínio. Guia da API Hy da Tencent
O orçamento de saída limita a geração. O limite de bytes do cliente define quanto do corpo HTTP ele lê, incluindo os campos de raciocínio. Ajuste os dois limites separadamente, mantendo a mesma entrada e configuração de raciocínio.
O caso 2 voltou a ser truncado em 8,192 tokens?
Repetimos três vezes o caso do catálogo com o Hy4, esforço médio e limite de 8,192 tokens. As três execuções passaram e informaram entre 5,106 e 7,155 tokens de raciocínio. Para a comparação com 16,384 tokens, reutilizamos as três requisições do catálogo com esforço médio do experimento com quatro configurações abaixo. As três passaram. As requisições com 8,192 tokens foram executadas depois. A requisição inicial com 8,192 tokens foi truncada, mas as três execuções posteriores com o mesmo limite terminaram. Essas repetições cobrem uma única entrada, com os dois limites testados em sequência. Ainda não sabemos se aumentar o limite reduz a taxa de truncamento.
Como as quatro configurações de raciocínio se compararam?
Executamos novamente os mesmos quatro casos no Hy4 pela Synthorai, três vezes para cada combinação de caso e esforço solicitado. Mantivemos fixos o prompt, o limite de 16,384 tokens, o limite de leitura de 512 KiB e o timeout de socket do cliente em 120 segundos. Testamos medium e none juntos. Depois, executamos low e high em outro lote.
| Esforço solicitado | Passou nas verificações dos campos JSON | Tokens de raciocínio informados | Mediana do corpo medido da resposta |
|---|---|---|---|
none | 12/12 | 0 em todas as execuções | 1,467 bytes |
low | 11/12 | 2,575 a 11,181 | 42,047 bytes |
medium | 12/12 | 2,989 a 9,317 | 51,780 bytes |
high | 12/12 | 2,911 a 9,987 | 58,369.5 bytes |
O intervalo de tokens e a mediana do corpo no grupo low consideram as 11 respostas medidas. Cada um dos outros três grupos tem 12 medições. Os intervalos observados nas requisições com low, medium e high se sobrepõem. Uma resposta com low informou 11,181 tokens de raciocínio, mais do que qualquer resposta com medium medida nesse teste.
Comparamos os dois resumos e a explicação de risco de cada resposta concluída com os eventos de origem. Nos dois idiomas, os resumos preservaram o serviço afetado, os dois eventos HTTP 503 e a recuperação confirmada. As explicações aplicaram a regra de gravidade fornecida e descreveram o sinal associado como observação. Essas verificações cobrem a fidelidade factual em quatro casos com um template comum e uma regra de gravidade explícita.
Como o cliente deve tratar essa falha do Hy4?
Considere um worker que publica um resumo em inglês e chinês quando o incidente do catálogo é encerrado. Como ele já tem os eventos de origem, registra em código os fatos que pode verificar. O serviço de catálogo retornou duas respostas HTTP 503 nos eventos 31 e 36, e o evento 49 confirmou a recuperação. A regra de pontuação resulta em gravidade 3. Com esses valores, o worker tem um critério de aceitação e também dados para retornar caso a geração do resumo falhe.
- Aceite apenas um resumo concluído e validado. O worker lê a resposta dentro do limite de bytes configurado e verifica se o encerramento foi
stopantes de inspecionar o JSON final. Para ser publicado, o objeto deve identificar o serviço de catálogo, informar gravidade 3 e citar[31, 36, 49]nessa ordem. Durante a implantação, valide os dois idiomas contra os mesmos eventos. Cada resumo deve mencionar as falhas e a recuperação confirmada. A explicação de risco pode citar a saturação observada do pool de conexões, mas qualquer relação causal exige evidências adicionais. Um encerramento comlengthreprova na validação, mesmo que o conteúdo parcial seja um JSON válido. - Faça uma única nova tentativa com limite bem definido. Neste exemplo, a primeira requisição usa
mediume um limite de 8,192 tokens. Se ela retornarlength, conteúdo vazio e uso de raciocínio igual ao limite, o worker poderá tentar novamente comnone, desde que essa configuração tenha sido validada na carga real da aplicação. Mantenha o prompt e o limite de tokens inalterados. Nossa comparação comnoneusou 16,384 tokens. Portanto, valide a nova tentativa com 8,192 antes de adotá-la. Preserve a falha original no log de tentativas e aplique os mesmos critérios de aceitação à nova resposta. O timeout de socket de 120 segundos do script de exemplo vale para uma chamada individual. O worker só deve repetir a requisição se o tempo restante permitir concluí-la dentro do prazo total do job. - Retorne um fallback explícito se a nova tentativa falhar ou o prazo acabar. Defina o status do resumo como
failedoupending_review, conforme alguém vá ou não revisá-lo, e deixe vazios os dois campos de resumo gerados. Mantenha disponíveis os metadados verificados do incidente e os IDs dos eventos de origem, para que o cliente ainda possa consultar as evidências. Armazene separadamente os resultados da primeira tentativa e da repetição. Uma nova tentativa bem-sucedida pode entregar o resumo sem ocultar a resposta vazia original do monitoramento.
Se o raciocínio continuar habilitado em cargas que exigem julgamento, dimensione o orçamento de saída com base no uso medido em entradas representativas, incluindo os tokens de raciocínio e da resposta final. Meça separadamente o tamanho total dos corpos antes de definir o limite do leitor, pois os bytes que a aplicação precisa manter em buffer também incluem o envelope da resposta. Considere o pico de concorrência ao escolher esse limite. Avalie a implantação pela proporção de requisições que produzem um resumo completo e correto, incluindo os timeouts no denominador. Analise separadamente a qualidade factual dos resumos retornados, inclusive se as evidências sustentam qualquer julgamento que a regra de pontuação deixe a cargo do modelo.
Como Hy4 e DeepSeek processaram os mesmos casos?
Enviamos cada um dos quatro prompts pela Synthorai uma vez para cada combinação de modelo e limite. Tanto o Hy4 quanto o DeepSeek V4.1 Flash (1017) receberam uma solicitação de esforço médio de raciocínio. Lemos cada resposta com um limite de 512 KiB e aplicamos o patamar de 128 KiB aos bytes recebidos.
| Modelo | Limite de saída solicitado | HTTP 200 | Acima de 128 KiB entre os corpos medidos | Passou nas verificações da resposta | Maior corpo lido (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 |
Os quatro casos seguem o mesmo padrão de eventos, e a comparação inicial usou uma tentativa por configuração. Considerando a execução inicial e todos os testes posteriores, 65 das 67 requisições produziram corpos mensuráveis. O maior tinha 89,739 bytes, abaixo do limite de 128 KiB (131,072 bytes) do cliente. As outras duas requisições atingiram o timeout antes dos headers da resposta no caso 3, com 16,384 tokens. Uma usava esforço médio na execução inicial, e a outra, esforço baixo no lote posterior. Ambas entram nos denominadores das verificações de resposta.
O que pedimos ao modelo?
Cada caso contém 72 eventos fictícios de serviços. Tudo opera normalmente, exceto duas respostas HTTP 503 de um serviço, um sinal como atraso na fila e uma recuperação confirmada. O prompt pede um único objeto JSON com um resumo em inglês, outro em chinês, o serviço afetado, uma pontuação de gravidade, uma explicação curta e os três IDs dos eventos usados como evidência. Também pede que o modelo mencione o sinal observado sem tratá-lo como causa.
Um resumo simples poderia pedir uma única frase sobre o ocorrido. Esse prompt também exige que o modelo encontre o serviço afetado entre eventos rotineiros, aplique uma regra de pontuação explícita e retorne referências que um programa possa verificar. Os casos usam o mesmo template, por isso conhecemos previamente o serviço, a pontuação e os IDs esperados. As verificações automatizadas cobrem a estrutura e esses valores exatos. Também exigem resumos não vazios e uma explicação de no máximo 480 caracteres. Elas não avaliam a qualidade da tradução nem verificam o texto de forma independente.
Salve este exemplo como replay.py e configure SYNTHORAI_API_KEY. Para executar o caso do catálogo, use python replay.py --case 2 --effort none --max-tokens 16384. Use --effort low, medium ou high para testar com raciocínio e --max-tokens 8192 para testar o limite menor. O script imprime o tamanho do corpo, o motivo do encerramento, o uso informado, a conclusão da geração e os resultados das verificações dos campos. O indicador geral de sucesso exige encerramento com stop e aprovação dos campos.
"""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))
Perguntas frequentes
O que acontece quando uma resposta ultrapassa o limite de 128 KiB do cliente?
O cliente pode interromper a leitura antes de conseguir interpretar a resposta final. Neste experimento com o Hy4, 128 KiB era o limite de bytes do leitor. O limite separado de tokens de saída controlava a geração.
Como saber se o Hy4 respeitou reasoning_effort none?
Verifique usage.completion_tokens_details.reasoning_tokens. O Hy4 informou zero nas 12 requisições feitas com reasoning_effort: "none" pela Synthorai. Se o campo estiver ausente, a resposta não fornece uma contagem que permita confirmar isso.