Tencent Hy4 为什么会在回答前耗尽 token

目录
  1. 目录服务摘要发生了什么?
  2. 如何排查答案为空的问题?
  3. Hy4 的推理和输出参数分别控制什么?
  4. 案例 2 是否再次在 8,192 个 token 处截断?
  5. 4 种推理设置的表现如何?
  6. 调用方应如何处理 Hy4 的这种失败?
  7. Hy4 和 DeepSeek 处理相同案例时表现如何?
  8. 我们要求模型完成什么任务?
  9. 常见问题
  10. 响应超过客户端的 128 KiB 限制时会怎样?
  11. 如何判断 Hy4 是否遵循了 reasoning_effort none?

Tencent Hy4 在处理一份合成的事件摘要时返回了 HTTP 200,但最终答案为空。响应显示使用了 8,192 个推理 token,正好等于请求的输出上限。在这条 API 路由上,思考过程与最终答案共用同一预算。如果客户端只检查 HTTP 状态码,就可能把 token 耗尽的响应误判为已完成的摘要。

TL;DR

  • Hy4 将全部 8,192 个输出 token 用于推理,最终答案为空,但仍返回了 HTTP 200。
  • 响应以 finish_reason: "length" 结束,大小为 68,410 字节,低于客户端设置的 128 KiB 阈值。
  • 在 4 个基于规则的事件中,与 medium 相比,none 在两种语言中都保留了关键信息,并将响应体中位数从 51,780 字节降至 1,467 字节。

目录服务摘要发生了什么?

我们要求 Hy4 使用英文和中文总结一次虚构的服务事件,按固定规则评定严重级别,并在 JSON 中引用故障和恢复事件。目录服务案例使用中等推理强度时,API 返回了 HTTP 200 和 finish_reason: "length"。在 8,192 个 token 的输出上限下,响应报告使用了 8,192 个推理 token,message.content 为空。完整响应为 68,410 字节,低于客户端设置的 128 KiB 阈值。

如何排查答案为空的问题?

客户端看到的现象应检查的内容
收到响应头前请求超时记录传输异常和耗时。此时客户端没有状态码或响应体可供检查。
读取器达到字节上限记录上限和已接收的字节数。客户端可能在解析答案前就停止了读取。
完整响应中的最终内容为空或不完整检查 finish_reason、message.content 和 usage.completion_tokens_details.reasoning_tokens。在目录服务案例中,length 和与输出上限相等的推理 token 数表明生成停止的位置。

将答案传给下游前,先确认生成是否完成。即使最终内容能解析为 JSON,字段也看起来正确,只要结束原因为 length,就说明生成过程触及了限制。生成完成后,还需要根据输入校验最终答案。

请求日志应同时保留原始响应状态和结束原因。如果统一记成“无效 JSON”,监控系统将无法区分答案缺失和答案已完成但字段错误这两种情况。两者的排查方向不同。前者需要检查预算和生成是否完成,后者需要检查 prompt、预期值和校验规则。

Hy4 的推理和输出参数分别控制什么?

请求参数 reasoning_effort 用于指定模型生成最终答案前的推理深度。 Tencent 的 TokenHub 文档为 Hy4 提供了两个思考控制项。thinking.type 字段通过 enabled 或 disabled 开启或关闭思考,默认开启。模型专属表格列出了 Hy4 的 reasoning_effort 可选值 high 和 no_think,默认值为 high。其他模型支持的选项不同。在不同提供商之间迁移请求时,应查看具体模型 ID 对应的行。Tencent TokenHub 深度思考指南

通过 Synthorai Chat Completions 测试时,我们分别发送了 none、low、medium 和 high 作为推理强度。TokenHub 文档描述的是其自有端点。这里的测量结果只反映 Synthorai 请求的行为,不能说明每个推理强度在所有上游端点中的映射方式。在本次测试的 Synthorai 路由上,使用 none 的 12 次请求都返回了最终答案,报告的推理 token 均为 0。应用应根据实际调用路由的响应结果做兼容性验证。如果更换端点或模型 ID,应使用已知输入重新测试,并在上线前确认推理用量和最终内容。

输出上限是另一项独立控制。我们通过 max_tokens 设置生成上限。如果模型在开始生成最终答案前就达到上限,即使 prompt 只要求返回一个很短的 JSON 对象,也可能得到空内容。Tencent 的故障排查指南通过 Hy3 示例说明了思考过程和答案共用配额的机制。这里对 Hy4 的测量表明,在本次测试的 Synthorai 路由上也存在相同的失败模式,全部 8,192 个 token 均被报告为推理 token。Tencent Hy API 指南

输出预算限制生成量。客户端的字节上限决定它能读取多少 HTTP 响应体,其中也包括推理字段。应在输入和推理设置保持一致的情况下,分别调整这两个限制。

案例 2 是否再次在 8,192 个 token 处截断?

我们使用 Hy4 以中等推理强度对目录服务案例重放了 3 次,输出上限均为 8,192 个 token。3 次都通过检查,报告的推理 token 为 5,106 至 7,155。对比 16,384 个 token 上限时,我们复用了下文 4 种设置实验中的 3 次中等推理强度请求,3 次也都通过。8,192 个 token 的请求在之后执行。最初那次 8,192 个 token 的请求被截断,后来在相同上限下执行的 3 次请求全部完成。这些重复测试只覆盖一个输入,而且两个上限是按顺序测试的。提高上限对截断率的影响仍无法确定。

4 种推理设置的表现如何?

我们通过 Synthorai 使用 Hy4 重新运行了相同的 4 个案例。每种案例和推理强度组合各运行 3 次。测试期间,prompt、16,384 个 token 的上限、512 KiB 的读取限制和 120 秒的客户端 socket 超时均保持不变。我们先同时测试 medium 和 none,之后再测试 low 和 high。

请求的推理强度通过 JSON 字段检查报告的推理 token响应体大小中位数
none12/12始终为 01,467 字节
low11/122,575 至 11,18142,047 字节
medium12/122,989 至 9,31751,780 字节
high12/122,911 至 9,98758,369.5 字节

low 组的 token 范围和响应体中位数基于 11 个测得的响应。其余 3 组各有 12 个测量结果。使用 low、medium 和 high 发出的请求,其 token 范围存在重叠。一个 low 响应报告了 11,181 个推理 token,超过本次测试中所有 medium 响应。

我们根据源事件检查了每个完整响应中的两种语言摘要和风险说明。两种语言的摘要都保留了受影响的服务、两次 HTTP 503 事件以及已确认恢复的信息。说明部分按给定的严重级别规则进行判断,并将伴随信号描述为观测结果。这些检查仅覆盖 4 个案例中的事实一致性,这些案例共用一个模板和明确的严重级别规则。

调用方应如何处理 Hy4 的这种失败?

假设某个 worker 在目录服务事件结束时发布英文和中文摘要。它已经掌握源事件,因此会先记录代码能够验证的事实。目录服务在事件 31 和 36 中两次返回 HTTP 503,事件 49 确认恢复。按评分规则,严重级别为 3。这些值既可用于验收,也能在摘要生成失败时作为返回内容。

  1. 只接受已完成且通过校验的摘要。worker 在配置的字节限制内读取响应,并在检查最终 JSON 前确认结束原因为 stop。要允许发布,对象必须标明目录服务、严重级别 3,并按顺序引用 [31, 36, 49]。上线期间,两种语言的摘要都应根据相同的事件事实进行校验。每份摘要都应反映故障和已确认恢复的信息。风险说明可以提到观测到的连接池饱和,但任何因果判断都需要额外证据。即使部分内容恰好可以解析,只要结束原因为 length,验收就应失败。
  2. 对空响应只进行一次有明确边界的重试。在这个例子中,首次请求使用 medium 和 8,192 个 token 的上限。如果响应以 length 结束、内容为空,而且推理用量等于上限,那么在 none 已通过自身工作负载测试的前提下,worker 可以改用 none 重试。prompt 和 token 上限应保持不变。我们的 none 对比实验使用的是 16,384 个 token,因此正式采用前,还需要在 8,192 个 token 下验证重试行为。尝试日志中应保留最初的失败记录,并对重试应用相同的验收检查。示例脚本中的 120 秒 socket 超时针对单次调用。只有当剩余时间足够在任务总截止时间前完成请求时,worker 才应重试。
  3. 重试失败或时间耗尽时,返回明确的降级结果。根据是否需要人工复核,将摘要状态设为 failed 或 pending_review,并将两种语言的生成摘要字段留空。保留已验证的事件元数据和源事件 ID,让调用方仍能查看证据。首次尝试和重试的结果应分别存储。即使重试成功并返回摘要,原始空响应也应继续保留在监控中。

如果工作负载确实需要模型判断,并且继续启用推理,应根据代表性输入中实测的完整生成用量来设置输出预算,其中包括推理 token 和最终答案 token。设置读取器上限前,还要单独测量完整响应体的大小,因为应用需要缓冲的内容也包括响应封装。选择该限制时还需评估峰值并发。上线效果应按能够生成完整且正确摘要的请求比例衡量,超时请求也要计入分母。返回摘要的事实质量需要单独评审,包括评分规则交由模型判断的部分是否有足够证据支持。

Hy4 和 DeepSeek 处理相同案例时表现如何?

我们通过 Synthorai 将 4 个 prompt 分别按每种模型和上限组合发送 1 次。Hy4 和 DeepSeek V4.1 Flash (1017) 的请求都使用中等推理强度。每个响应的读取上限为 512 KiB,并根据实际接收的字节数应用 128 KiB 阈值。

模型请求的输出上限HTTP 200已测响应体中超过 128 KiB通过答案检查读取到的最大响应体(字节)
Hy48,1924/40/43/468,410
DeepSeek V4.1 Flash (1017)8,1924/40/44/43,595
Hy416,3843/40/33/447,934
DeepSeek V4.1 Flash (1017)16,3844/40/44/44,127

这 4 个案例采用相同的事件模式,初始对比中每种配置只运行 1 次。初始测试和所有后续测试共发出 67 个请求,其中 65 个获得了可测量的响应体。最大响应体为 89,739 字节,低于客户端设置的 128 KiB(131,072 字节)阈值。另外 2 个请求都在收到响应头前超时,均发生在案例 3、16,384 个 token 的配置下。其中一次来自初始测试,使用中等推理强度;另一次来自后续批次,使用低推理强度。计算答案检查的请求总数时,这两次都计入分母。

我们要求模型完成什么任务?

每个案例包含 72 个虚构的服务事件。除某个服务返回两次 HTTP 503、出现队列延迟等信号,以及之后确认恢复之外,其余事件均正常。prompt 要求模型返回一个 JSON 对象,其中包含英文摘要、中文摘要、受影响的服务、严重级别分数、简短说明和 3 个支持结论的事件 ID。模型需要提到观测到的信号,但不能将其视为故障原因。

普通的摘要任务可能只要求用一句话说明发生了什么。这个 prompt 还要求模型从日常事件中找出受影响的服务,应用明确的评分规则,并返回程序可以验证的引用。所有案例共用一个模板,因此预期的服务、分数和事件 ID 都是已知的。自动检查覆盖结构和这些精确值,同时要求摘要非空,说明不超过 480 个字符。它不会评估翻译质量,也不会独立验证自然语言内容。

将以下示例保存为 replay.py,并设置 SYNTHORAI_API_KEY。运行 python replay.py --case 2 --effort none --max-tokens 16384 可测试目录服务案例。使用 --effort low、medium 或 high 测试启用推理的情况,使用 --max-tokens 8192 测试较低的上限。脚本会输出响应体大小、结束原因、报告的用量、生成是否完成以及字段检查结果。只有结束原因为 stop 且字段检查通过时,整体成功标志才为真。

"""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))

常见问题

响应超过客户端的 128 KiB 限制时会怎样?

客户端可能在解析最终答案前停止读取响应。在这次 Hy4 实验中,128 KiB 是读取器的字节阈值。生成过程则由单独的输出 token 上限控制。

如何判断 Hy4 是否遵循了 reasoning_effort none?

检查 usage.completion_tokens_details.reasoning_tokens。通过 Synthorai 使用 reasoning_effort: "none" 发出的 12 次 Hy4 请求中,该值均为 0。如果字段缺失,响应就没有提供可供验证的计数。

← 返回博客