Por qué Tencent Hy4 agota los tokens antes de responder
Contenido
- ¿Qué ocurrió con el resumen del catálogo?
- ¿Cómo se diagnostica una respuesta vacía?
- ¿Qué controlan los parámetros de razonamiento y salida de Hy4?
- ¿El caso 2 volvió a truncarse en 8,192 tokens?
- ¿Cómo se compararon las cuatro configuraciones de razonamiento?
- ¿Cómo debe gestionar un cliente este fallo de Hy4?
- ¿Cómo procesaron Hy4 y DeepSeek los mismos casos?
- ¿Qué le pedimos al modelo?
- Preguntas frecuentes
- ¿Qué ocurre cuando una respuesta supera el límite de 128 KiB del cliente?
- ¿Cómo puedo saber si Hy4 respetó reasoning_effort none?
Tencent Hy4 devolvió HTTP 200 con una respuesta final vacía al resumir un incidente sintético. Declaró 8,192 tokens de razonamiento, justo el límite de salida solicitado. En esta ruta de la API, el razonamiento y la respuesta final comparten el mismo presupuesto. Si un cliente solo comprueba el estado HTTP, puede interpretar como completo un resumen que agotó los tokens.
TL;DR
- Hy4 devolvió HTTP 200 con una respuesta final vacía tras gastar los 8,192 tokens de salida en razonamiento.
- La respuesta terminó con
finish_reason: "length"y ocupó 68,410 bytes, por debajo del límite de 128 KiB del cliente. - En cuatro incidentes basados en reglas,
noneconservó los datos clave en ambos idiomas y redujo la mediana del cuerpo de respuesta de 51,780 a 1,467 bytes frente amedium.
¿Qué ocurrió con el resumen del catálogo?
Pedimos a Hy4 que resumiera en inglés y chino un incidente ficticio de servicio, puntuara su gravedad según una regla fija y citara en JSON los eventos de fallo y recuperación. En el caso del catálogo con esfuerzo medio, la API devolvió HTTP 200 y finish_reason: "length". Declaró 8,192 tokens de razonamiento frente a un límite de salida de 8,192 tokens, y message.content estaba vacío. La respuesta completa ocupó 68,410 bytes, por debajo del límite de 128 KiB de nuestro cliente.
¿Cómo se diagnostica una respuesta vacía?
| Lo que ve el cliente | Qué comprobar |
|---|---|
| La solicitud agota el tiempo de espera antes de recibir las cabeceras | Registra la excepción de transporte y el tiempo transcurrido. El cliente no dispone de ningún estado ni cuerpo de respuesta que inspeccionar. |
| El lector alcanza su límite de bytes | Registra el límite y los bytes recibidos. Puede que el cliente se detuviera antes de poder analizar la respuesta. |
| La respuesta completa tiene contenido final vacío o parcial | Comprueba finish_reason, message.content y usage.completion_tokens_details.reasoning_tokens. En el caso del catálogo, length y un recuento de razonamiento igual al límite de salida indican dónde se detuvo la generación. |
Comprueba que la generación haya terminado antes de enviar la respuesta a los sistemas posteriores. Aunque el contenido final se pueda analizar como JSON y los campos parezcan correctos, un final length indica que la generación alcanzó un límite. Cuando termine la generación, valida la respuesta final contra la entrada.
Guarda juntos en los logs de cada solicitud el estado original de la respuesta y el motivo de finalización. Si ambos casos se convierten en un error genérico de «JSON no válido», una respuesta ausente y otra completa con un campo incorrecto tendrán el mismo aspecto en la monitorización. Sin embargo, requieren investigaciones distintas. En el primer caso, hay que comprobar el presupuesto y si terminó la generación. En el segundo, hay que revisar el prompt, los valores esperados y las reglas de validación.
¿Qué controlan los parámetros de razonamiento y salida de Hy4?
El parámetro de solicitud reasoning_effort indica cuánto debe razonar el modelo antes de emitir la respuesta final. La documentación de TokenHub de Tencent ofrece dos controles para el razonamiento de Hy4. El campo thinking.type lo activa o desactiva mediante enabled o disabled. Está activado por defecto. La tabla específica del modelo enumera high y no_think como opciones de reasoning_effort para Hy4, con high como valor predeterminado. Esa misma tabla incluye opciones diferentes para otros modelos. Si trasladas una solicitud de un proveedor a otro, consulta la fila del ID exacto del modelo. Guía de razonamiento profundo de Tencent TokenHub
En Synthorai Chat Completions enviamos none, low, medium y high como valores de esfuerzo solicitados. La documentación de TokenHub describe su propio endpoint. Nuestras mediciones reflejan el comportamiento de las solicitudes a Synthorai, pero no permiten determinar cómo se traduce cada nivel de esfuerzo en todos los proveedores. En la ruta de Synthorai probada, none devolvió una respuesta final sin tokens de razonamiento declarados en las 12 repeticiones. Usa esa medición como comprobación de compatibilidad para la ruta que llama tu aplicación. Si cambias de endpoint o de ID de modelo, repite una prueba con una entrada conocida y confirma el uso de razonamiento y el contenido final antes de desplegar el cambio.
El límite de salida es un control independiente. Enviamos max_tokens para fijar el máximo solicitado para la generación. Si el modelo alcanza ese límite antes de empezar la respuesta final, incluso un prompt que pida un objeto JSON breve puede devolver contenido vacío. La guía de resolución de problemas de Tencent describe en su ejemplo con Hy3 cómo el razonamiento y la respuesta comparten el presupuesto. La medición de Hy4 muestra el mismo patrón de fallo en la ruta de Synthorai probada: los 8,192 tokens se declararon como razonamiento. Guía de la API Hy de Tencent
El presupuesto de salida limita la generación. El límite de bytes del cliente determina cuánto lee del cuerpo HTTP, incluidos los campos de razonamiento. Ajusta ambos límites por separado, con la misma entrada y configuración de razonamiento.
¿El caso 2 volvió a truncarse en 8,192 tokens?
Repetimos tres veces el caso del catálogo con Hy4, esfuerzo medio y un límite de 8,192 tokens. Las tres ejecuciones pasaron las comprobaciones y declararon entre 5,106 y 7,155 tokens de razonamiento. Para la comparación con 16,384 tokens, reutilizamos las tres solicitudes del catálogo con esfuerzo medio del experimento de cuatro configuraciones que aparece más adelante. Las tres pasaron. Las solicitudes con 8,192 tokens se ejecutaron después. La solicitud inicial con ese límite se truncó, pero las tres posteriores terminaron. Estas repeticiones cubren una sola entrada y los dos límites se probaron de forma secuencial. No está claro hasta qué punto aumentar el límite reduce la tasa de truncamiento.
¿Cómo se compararon las cuatro configuraciones de razonamiento?
Repetimos tres veces los mismos cuatro casos con Hy4 a través de Synthorai para cada caso y nivel de esfuerzo solicitado. Mantuvimos fijos el prompt, el límite de 16,384 tokens, el límite de lectura de 512 KiB y el timeout de socket del cliente de 120 segundos. Probamos medium y none juntos, y después ejecutamos low y high en otro lote.
| Esfuerzo solicitado | Superó las comprobaciones de campos JSON | Tokens de razonamiento declarados | Mediana del cuerpo de respuesta medido |
|---|---|---|---|
none | 12/12 | 0 en todas las ejecuciones | 1,467 bytes |
low | 11/12 | De 2,575 a 11,181 | 42,047 bytes |
medium | 12/12 | De 2,989 a 9,317 | 51,780 bytes |
high | 12/12 | De 2,911 a 9,987 | 58,369.5 bytes |
El rango de tokens y la mediana del cuerpo del grupo low se calculan a partir de sus 11 respuestas medidas. Cada uno de los otros tres grupos tiene 12 mediciones. Los rangos de tokens observados para las solicitudes enviadas con low, medium y high se solapan. Una respuesta low declaró 11,181 tokens de razonamiento, más que cualquier respuesta medium medida en esta prueba.
Comparamos ambos resúmenes y la explicación del riesgo de cada respuesta completa con los eventos de origen. En ambos idiomas, los resúmenes conservaron el servicio afectado, los dos eventos HTTP 503 y la recuperación confirmada. Las explicaciones aplicaron la regla de gravedad proporcionada y describieron la señal asociada como una observación. Estas comprobaciones cubren la fidelidad de los hechos en cuatro casos con una plantilla común y una regla de gravedad explícita.
¿Cómo debe gestionar un cliente este fallo de Hy4?
Pensemos en un worker que publica un resumen en inglés y chino cuando se cierra el incidente del catálogo. Como ya dispone de los eventos de origen, registra los hechos que puede verificar mediante código. El servicio de catálogo devolvió dos respuestas HTTP 503 en los eventos 31 y 36, y el evento 49 confirmó la recuperación. La regla de puntuación da como resultado una gravedad 3. Con estos valores, el worker puede validar la respuesta y disponer de datos que devolver si falla la generación del resumen.
- Acepta solo resúmenes completos y validados. El worker lee la respuesta dentro del límite de bytes configurado y comprueba que el motivo de finalización sea
stopantes de inspeccionar el JSON final. Para publicarlo, el objeto debe identificar el servicio de catálogo, indicar gravedad 3 y citar[31, 36, 49]en ese orden. Durante el despliegue, valida ambos idiomas contra los mismos eventos. Cada resumen debe reflejar los fallos y la recuperación confirmada. La explicación del riesgo puede mencionar la saturación observada del pool de conexiones, pero cualquier afirmación causal exige más pruebas. Un finallengthno supera la validación, aunque el contenido parcial pueda analizarse. - Haz un solo reintento acotado si la respuesta está vacía. En este ejemplo, la primera solicitud usa
mediumy un límite de 8,192 tokens. Si devuelvelength, contenido vacío y un uso de razonamiento igual al límite, el worker puede reintentar connonesi esa configuración ya ha superado las pruebas de su propia carga de trabajo. Mantén fijos el prompt y el límite de tokens. Nuestra comparación connoneusó 16,384 tokens, así que valida el reintento con 8,192 antes de adoptarlo. Conserva el fallo original en el log de intentos y aplica al reintento las mismas comprobaciones. El timeout de socket de 120 segundos del script de ejemplo se aplica a cada llamada. El worker solo debe reintentar si queda tiempo suficiente para terminar dentro del plazo total del job. - Devuelve un fallback explícito si falla el reintento o se agota el tiempo. Establece el estado del resumen en
failedopending_review, según vaya a revisarlo alguien o no, y deja vacíos ambos campos del resumen generado. Mantén disponibles los metadatos verificados del incidente y los ID de los eventos de origen para que el cliente pueda consultar las pruebas. Guarda por separado los resultados del primer intento y del reintento. Si el reintento funciona, se puede entregar el resumen sin ocultar la respuesta vacía original en la monitorización.
Si mantienes el razonamiento en cargas que requieren evaluación, dimensiona el presupuesto de salida según el uso de tokens medido en entradas representativas, incluidos tanto los tokens de razonamiento como los de la respuesta final. Mide por separado el tamaño de los cuerpos completos antes de fijar el límite de lectura, porque los bytes que debe almacenar la aplicación también incluyen la envoltura de la respuesta. Ten en cuenta el pico de concurrencia al elegir ese límite. Evalúa el despliegue según la proporción de solicitudes que generan un resumen completo y correcto, contando los timeouts en el denominador. Revisa por separado la calidad factual de los resúmenes devueltos, incluida la solidez de las pruebas que respaldan cualquier valoración que la regla de puntuación deje en manos del modelo.
¿Cómo procesaron Hy4 y DeepSeek los mismos casos?
Enviamos una vez cada uno de los cuatro prompts a través de Synthorai para cada combinación de modelo y límite. Tanto Hy4 como DeepSeek V4.1 Flash (1017) recibieron una solicitud con esfuerzo de razonamiento medio. Leímos cada respuesta con un margen de 512 KiB y aplicamos el umbral de 128 KiB a los bytes recibidos.
| Modelo | Límite de salida solicitado | HTTP 200 | Superó 128 KiB entre los cuerpos medidos | Superó las comprobaciones de la respuesta | Mayor cuerpo leído (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 |
Los cuatro casos comparten un patrón de eventos y la comparación inicial usó un intento por configuración. Entre la ejecución inicial y todas las pruebas posteriores, 65 de 67 solicitudes produjeron cuerpos medibles. El mayor ocupó 89,739 bytes, por debajo del umbral de 128 KiB (131,072 bytes) de nuestro cliente. Las otras dos solicitudes agotaron el tiempo de espera antes de recibir las cabeceras de respuesta en el caso 3 con 16,384 tokens. Una usó esfuerzo medio en la ejecución inicial y la otra, esfuerzo bajo en el lote posterior. Ambas se incluyen en los denominadores de solicitudes de las comprobaciones de respuesta.
¿Qué le pedimos al modelo?
Cada caso contiene 72 eventos ficticios de servicio. Todo funciona con normalidad salvo por dos respuestas HTTP 503 de un servicio, una señal como un retraso en la cola y una recuperación confirmada. El prompt pide un único objeto JSON con un resumen en inglés, otro en chino, el servicio afectado, una puntuación de gravedad, una breve explicación y los tres ID de los eventos que la respaldan. También pide mencionar la señal observada sin tratarla como la causa.
Un resumen sencillo podría limitarse a describir lo ocurrido en una frase. Este prompt también pide al modelo que encuentre el servicio afectado entre eventos rutinarios, aplique una regla de puntuación explícita y devuelva referencias que un programa pueda verificar. Los casos comparten una plantilla, por lo que se conocen el servicio, la puntuación y los ID de eventos esperados. Las comprobaciones automatizadas validan la estructura y estos valores exactos. También exigen resúmenes no vacíos y una explicación de 480 caracteres como máximo. No evalúan la calidad de la traducción ni verifican el texto de forma independiente.
Guarda este ejemplo como replay.py y define SYNTHORAI_API_KEY. Ejecuta python replay.py --case 2 --effort none --max-tokens 16384 para el caso del catálogo. Usa --effort low, medium o high para probar con razonamiento y --max-tokens 8192 para probar el límite inferior. El script muestra el tamaño del cuerpo, el motivo de finalización, el uso declarado, si terminó la generación y los resultados de las comprobaciones de campos. Para que el indicador global de éxito sea verdadero, el motivo de finalización debe ser stop y los campos deben superar las comprobaciones.
"""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))
Preguntas frecuentes
¿Qué ocurre cuando una respuesta supera el límite de 128 KiB del cliente?
El cliente puede dejar de leer la respuesta antes de poder analizar la respuesta final. En este experimento con Hy4, 128 KiB era el umbral de bytes del lector. El límite de tokens de salida, que es independiente, controlaba la generación.
¿Cómo puedo saber si Hy4 respetó reasoning_effort none?
Comprueba usage.completion_tokens_details.reasoning_tokens. Hy4 declaró cero en las 12 solicitudes realizadas a través de Synthorai con reasoning_effort: "none". Si el campo no está presente, la respuesta no ofrece ningún recuento que permita verificarlo.