---
title: "思考模型 max_tokens 怎么设：避免空回复的预算方法 | BroadRouter"
description: "为什么 max_tokens 设得低时思考模型会返回空回复，以及怎样根据实测分位数、上下文窗口和逐级加倍的重试来确定预算。"
url: https://broadrouter.com/zh/blog/reasoning-model-max-tokens-budget/
lang: zh-Hans
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

本页由英文原文借助 AI 翻译。[阅读英文原文](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/)（2026-11-15 更新）。

# 思考模型的 max\_tokens 怎么设：一套预算方法

BroadNet Inference 团队 · 阅读约 6 分钟 · 发布于 2026-11-15

在思考模型上，max\_tokens 同时限制思考和回答，限制太紧时回复可能在出现任何可见文本前就被截断。按任务类型测量总输出 token，把 max\_tokens 设为第 95 百分位数再加 20% 左右，保证提示词加 max\_tokens 不超过上下文窗口，并对被截断的回复以加倍预算重试，直到硬上限。

## 要点

-   max\_tokens 是上限，不是收费额。你按实际生成的 token 付费，所以宽松的上限对提前结束的回复不多花一分钱。
-   真正花钱的是过紧的上限：被截断的回复照样为思考计费，却没有答案，还得重新发送。
-   按任务类型、根据自己的日志定预算：输出 token 的第 95 百分位数加 20% 余量，是一个可靠的起点。
-   提示词 token 加 max\_tokens 必须装得进上下文窗口：Qwen3.8 27B 为 262,144 token，GLM 5.3 和 DeepSeek V4.1 Flash 为 1,048,576。
-   把 finish\_reason 为 "length" 当作信号：用加倍的预算或更低的 reasoning\_effort 重试，并设硬上限。

**本页内容**

1.  为什么预算在答案出来之前就用完了？
2.  max\_tokens 设得大会更贵吗？
3.  怎样测量一个任务需要多少？
4.  上下文窗口怎样限制预算？
5.  回复仍然被截断时怎么办？
6.  流式输出会带来什么变化？
7.  应该发送哪个参数名？
8.  BroadNet Inference 适合什么场景

思考模型先思考再回答，而在大多数 OpenAI 兼容 API 上，两者共用一个预算：`max_tokens`。如果像对待非思考模型那样设置，比如为一个简短回答留几百 token，有些回复就会以 `finish_reason: "length"` 空着返回。快速修复见[思考模型为什么返回空答案](https://broadrouter.com/zh/guides/reasoning-tokens-empty-response/)。本文讲的是一个可信预算背后的方法：测量、按分位数定额、遵守上下文窗口，并处理仍然被截断的回复。

思考要花多少钱、怎样降低，请看[思考 token：为什么你付费的输出比看到的多](https://broadrouter.com/zh/blog/reasoning-tokens-cost/)。

## 为什么预算在答案出来之前就用完了？

模型按顺序生成：先是思考，再是可见的答案。两者的每个 token 都计入 `max_tokens`。BroadNet 的文档针对 DeepSeek V4.1 Flash、GLM 5.3 和 Qwen3.8 27B 写道：“the reasoning counts toward max\_tokens”（译文：思考计入 max\_tokens），限制太小时“the answer comes back empty”（译文：答案返回为空）。OpenAI 的 Chat Completions 参考对 `max_completion_tokens` 的定义也一样，是一个“including visible output tokens and reasoning tokens”（译文：包括可见输出 token 和推理 token）的上限。

所以要问的不是“我的答案有多长？”，而是“在这个任务、这个思考强度下，思考加答案一共多长？”。这个数字的波动比人们想象的大。OpenAI 的指南说，视问题而定，其模型可能生成“anywhere from a few hundred to tens of thousands of reasoning tokens”（译文：从几百到几万个推理 token 不等）。

## max\_tokens 设得大会更贵吗？

不会。这正是预算被设得过紧的最常见原因。[`max_tokens`](https://broadrouter.com/zh/glossary/max-tokens/) 是一个上限，你按实际生成的 token 计费。一条需要 1,800 token 的回复，上限设 4,000 还是 40,000，费用都一样。

过紧的上限真正的代价：

| 上限与需求 | 你付的钱 | 你得到的 |
| --- | --- | --- |
| 上限高于需求 | 实际生成的 token | 答案 |
| 上限低于需求 | 整个上限，全部是思考 | 没有可用结果，还要重试 |

举个例子。假设你有四分之一的调用需要超过 1,000 token。设 `max_tokens=1000` 时，这些调用每次都计费 1,000 个思考输出 token，什么也没返回，还要重试。平摊到所有调用，每次平均多浪费 250 个输出 token，这还没算重试本身，以及第二次请求带来的延迟。把上限设为 4,000，就没有任何浪费。[Qwen3.8 27B](https://broadrouter.com/zh/models/qwen3.8-27b/) 的输出价格是每 100 万 token $2.17，量一大，浪费就很可观。

高上限真正的风险是失控的回复：模型陷入循环或过度思考，生成远超所需的内容。硬上限可以兜住这一点。上限要按数据来定，方法如下。

## 怎样测量一个任务需要多少？

针对一种任务类型，用宽松的上限运行真实提示词，记录输出 token 和思考所占的比例。模型提供时，`usage.completion_tokens_details.reasoning_tokens` 给出思考部分；BroadNet 的文档列出了这个字段。

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
```

想得到一个可信的数字，要遵守这些规则：

1.  **每次只测一种任务类型。** 分类、抽取、代码审查和规划的分布差别很大。一个全局的 `max_tokens`，要么在重试上浪费钱，要么放任失控的回复。
2.  **50 条以上的真实提示词。** 十个样本的第 95 百分位数，其实就是最大的那个。
3.  **你用到的每个思考强度都要测。** `reasoning_effort="low"` 会改变分布。BroadNet 文档写的是 `low`；其他取值请先测试再依赖。
4.  **如果 `cut_off` 不为零，提高上限再跑一次。** 被截断的样本掩盖了它真实的长度。
5.  **模型或提示词变了就重新测。** 新版本的模型可能思考得更多或更少。

然后按 `recommend()` 的结果为每种任务设置 `max_tokens`。第 95 百分位数加 20%，能让大多数调用远低于上限，只把少数特别长的回复交给下面的重试路径。拿到数据后，免费的[思考 token 预算工具](https://broadrouter.com/tools/reasoning-token-budget/)可以在浏览器里帮你算完。

## 上下文窗口怎样限制预算？

上下文窗口同时容纳提示词和答案。BroadNet 的价格数据把 `context_length` 定义为“the most tokens one request can hold, prompt and answer together”（译文：一个请求最多能容纳的 token 数，提示词和答案合计）。因此：

**max\_tokens ≤ 上下文长度 − 提示词 token**

| 模型 | 上下文 | 提示词为 200,000 token 时 max\_tokens 的可用空间 |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/zh/models/glm-5.3/) | 1,048,576 | 848,576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/zh/models/deepseek-v4.1-flash/) | 1,048,576 | 848,576 |
| Qwen3.8 27B | 262,144 | 62,144 |

这对长上下文任务很重要。一个在 Qwen3.8 27B 上把历史累积到 250,000 token 的智能体，只剩约 12,000 token 给思考和答案。长上下文任务往往还需要更多思考，所以要在每次调用时检查剩余空间，而不是只在启动时查一次。是否装得下，见[上下文窗口](https://broadrouter.com/zh/glossary/context-window/)和[上下文窗口计算器](https://broadrouter.com/tools/context-window-calculator/)。

## 回复仍然被截断时怎么办？

每次调用都检查 `finish_reason`。如果是 `length`，答案就是缺失或不完整的，即使 `content` 里有一些文本。不要把它当作完整结果解析；被截断的 JSON 对象是下游出错的常见原因（[结构化输出](https://broadrouter.com/zh/blog/structured-output-json-schema/)）。

在上下文允许的空间内，以加倍的预算重试，直到硬上限：

```python
import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt
```

视任务而定，加倍之外还有两种办法：

-   **以 `reasoning_effort="low"` 重试**，预算不变。简单任务上模型常常想得过多，降低思考强度不用提高上限就能解决。
-   **拆分任务。** 如果某个回复总是撞到很高的上限，通常说明这个请求一次要的东西太多了。

记录每次截断及其任务类型。截断率上升，说明提示词、模型或输入数据变了，预算需要重新测量。重试是新的推理，会再次计费，所以要像[长时间运行的智能体：超时与重试](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)中那样限制重试次数。

## 流式输出会带来什么变化？

使用 `stream=True` 时，思考发生在第一个可见 token 之前，所以思考模型在开头可能看起来像卡住了。在聊天界面里，内容到来之前显示一个“思考中”状态，客户端超时也要按思考时间来设，而不只是按答案。

有些服务端还会在单独的字段里流式输出思考文本本身。这个字段名并不统一：DeepSeek 自己的 API 用 `reasoning_content`，vLLM 则把字段从 `reasoning_content` 改名为 `reasoning`，并警告旧的客户端代码“could silently read an empty”（译文：可能悄无声息地读到一个空的）字段。BroadNet 的文档没有说明思考文本字段，所以在没检查过你所用模型的原始响应之前，不要基于它开发功能。如果确实要读，请防御性地读取：

```python
for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
```

最后一个数据块里的 usage 需要 `stream_options={"include_usage": True}`，BroadNet 的文档有说明。流式输出的更多内容见[流式输出指南](https://broadrouter.com/zh/guides/streaming-chat-completions/)和 [SSE 详解](https://broadrouter.com/zh/blog/llm-streaming-sse-explained/)。

## 应该发送哪个参数名？

| API | 参数 | 是否包含思考 |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens`（`max_tokens` 已弃用） | 是 |
| OpenAI Responses | `max_output_tokens` | 是 |
| BroadNet Inference（Chat Completions） | `max_tokens`，按文档说明 | 是 |
| vLLM 服务端 | `max_tokens`，以及可选的 `thinking_token_budget` | 是 |

在不同供应商之间迁移代码时，发送该供应商文档里写的参数名，并用一次测试调用确认限制确实生效。一个被悄悄忽略的限制，在失控回复出现之前看起来一切正常。其他会变化的参数见[迁移检查清单](https://broadrouter.com/zh/blog/openai-compatible-api-migration-checklist/)。

## BroadNet Inference 适合什么场景

BroadNet 的三个思考模型在模型提供思考 token 数时，会在 `usage` 中报告，所以上面的测量方法可以直接使用。DeepSeek V4.1 Flash 和 GLM 5.3 的空间最大，上下文为 1,048,576 token；Qwen3.8 27B 为 262,144。如果某个任务不需要思考，[Gemma 4 VL 26B](https://broadrouter.com/zh/models/gemma-4-vl-26b/) 没有被列为思考模型，可以完全绕开预算问题。在固定价格的 [DeepSeek V4.1 Flash 套餐](https://broadrouter.com/zh/guides/unlimited-llm-api-sessions/)上，思考 token 不按 token 计费，但被截断的回复仍然浪费时间，所以同样的预算方法依然适用。BroadNet 没有说明单独的思考上限；如果你需要，请选择提供该功能的供应商或自托管服务端。

相关免费工具（英文）

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[免费工具（英文）](https://broadrouter.com/tools/)

## 本文涉及的术语

[Token（词元）](https://broadrouter.com/zh/glossary/token/)

token（词元）是大语言模型读写文本的基本单位：由模型的分词器切分出的一个词、词的一部分、一个标点或一段字节序列。大模型 API 按 token 计数、设定限制，通常也按 token 计费。

[思考 token（reasoning tokens）](https://broadrouter.com/zh/glossary/reasoning-tokens/)

思考 token（reasoning tokens）是推理模型在写出可见回答之前、为解决问题而生成的 token。它们通常按输出 token 计费，计入输出上限和上下文窗口，API 可能将其隐藏或只返回摘要。

[输入 token 与输出 token](https://broadrouter.com/zh/glossary/input-and-output-tokens/)

输入 token 是语言模型在一次请求中读取的 token，包括系统提示词、对话历史、工具定义和图片。输出 token 是模型生成回复的 token，包括思考内容。大模型 API 通常分别计价，输出一般更贵。

[max\_tokens（最大输出 token 数）](https://broadrouter.com/zh/glossary/max-tokens/)

max\_tokens 是大模型 API 的一个参数，用于设定模型在一次回复中最多能生成多少 token。生成达到上限时就会停止，响应会被标记为截断，例如 finish\_reason 为 "length"。

[Chat Completions API（对话补全接口）](https://broadrouter.com/zh/glossary/chat-completions-api/)

Chat Completions API 是 OpenAI 的 HTTP 端点 POST /v1/chat/completions，它接收模型名称和一组带角色标记的消息，返回模型的下一条消息。它的请求与响应结构已成为 OpenAI 兼容服务商和各类 SDK 通用的格式。

[工具调用（tool calling / function calling）](https://broadrouter.com/zh/glossary/tool-calling/)

工具调用（也叫函数调用，function calling）是大模型 API 的一项功能：模型返回一个结构化请求，要求执行开发者定义的某个函数，并附上 JSON 参数。应用执行该函数并把结果发回；模型自己从不执行代码。

[AI 智能体（AI agent）](https://broadrouter.com/zh/glossary/agent/)

AI 智能体是由语言模型自主决定步骤、朝目标推进的系统：它决定调用哪些工具、读取结果，然后重复，直到给出最终回答或触及上限。在固定位置调用模型的固定脚本，通常称为工作流（workflow）。

[vLLM](https://broadrouter.com/zh/glossary/vllm/)

vLLM 是一个用于 LLM 推理和服务部署的开源库，最初由加州大学伯克利分校 Sky Computing Lab 开发。它用 PagedAttention 管理 KV 缓存内存，对请求做连续批处理，支持多种量化格式，并提供 OpenAI 兼容的 HTTP 服务器。

## 常见问题

### 为什么我的思考模型返回空回复？

模型在写答案之前，就把整个 max\_tokens 预算花在了隐藏的思考上，此时 finish\_reason 为 "length"。调高 max\_tokens、调低 reasoning\_effort，或两者都做。本文附有一篇给出快速修复方法的简短指南。

### 思考模型的 max\_tokens 应该设多少？

先测量。用宽松的上限跑 50 条以上的真实提示词，取该任务 completion\_tokens 的第 95 百分位数，再加 20% 左右。BroadNet 文档给出的下限是 1,000 token 或更多；OpenAI 建议刚开始使用其模型时预留 25,000。

### max\_tokens 设得更高会更贵吗？

本身不会。你按模型生成的 token 计费，而不是按上限。只有当回复原本会被截断时，更高的上限才会多花钱；而那种情况下，被截断的回复本来也要让你多付一次重试。

### max\_completion\_tokens 和 max\_tokens 是一回事吗？

在 OpenAI 上，max\_completion\_tokens 取代了已弃用的 max\_tokens，并明确包含推理 token。许多 OpenAI 兼容供应商的文档写的仍是 max\_tokens。BroadNet 的文档使用 max\_tokens，并说明思考计入其中。

### 能单独限制思考部分、不限制回答吗？

只有服务端支持时才行。vLLM 有 thinking\_token\_budget 参数，一些供应商也有自己的参数。BroadNet 文档提供的是把 reasoning\_effort 设为 low，而不是单独的思考上限，所以要把两者合在一起做预算。

## 继续阅读

-   [思考 token：为什么你付费的输出比看到的多](https://broadrouter.com/zh/blog/reasoning-tokens-cost/)
-   [大模型流式输出详解：SSE 分块、delta、用量与取消](https://broadrouter.com/zh/blog/llm-streaming-sse-explained/)
-   [JSON 模式与 json\_schema：靠得住的结构化输出](https://broadrouter.com/zh/blog/structured-output-json-schema/)
-   [长时间运行的智能体：可靠的超时、重试与检查点](https://broadrouter.com/zh/blog/long-running-agents-timeouts-retries/)
-   [迁移到 OpenAI 兼容 API：切换服务商检查清单](https://broadrouter.com/zh/blog/openai-compatible-api-migration-checklist/)
-   [BroadNet 的 GPU 硬件与推理部署方式（据 BroadNet 自述）](https://broadrouter.com/zh/blog/broadnet-gpu-fleet-and-serving/)
-   [缓存大模型 API 响应以降低成本：用 Python 实现精确匹配缓存](https://broadrouter.com/zh/blog/cache-llm-responses-cut-cost/)
-   [指南：推理模型为什么返回空回答](https://broadrouter.com/zh/guides/reasoning-tokens-empty-response/)
-   [指南：对话补全的流式输出，以及连接中断的处理](https://broadrouter.com/zh/guides/streaming-chat-completions/)
-   [指南：用 OpenAI Python SDK 调用 BroadNet Inference](https://broadrouter.com/zh/guides/openai-python-sdk/)

用你的真实业务负载试一试。新账户可获得 US$5 初始额度，用于 Gemma和转写。DeepSeek、GLM和Qwen3.8 需要先充值。

[开始使用](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**来源**

-   [BroadNet Inference API 参考：思考计入 max\_tokens，1,000 token 或更多，reasoning\_effort 为 low，usage 字段（2026-11-15 核对）（英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [BroadNet pricing.json 字段说明：context\_length 同时容纳提示词和回答（2026-11-15 核对）（英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [OpenAI 推理指南：不完整的响应，刚开始时至少预留 25,000 token（2026-11-15 核对）](https://developers.openai.com/api/docs/guides/reasoning)
-   [OpenAI Chat Completions 参考：max\_completion\_tokens 包含推理 token；max\_tokens 已弃用（2026-11-15 核对）](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [DeepSeek API 文档，思考模式：reasoning\_content 字段、思考强度等级（2026-11-15 核对）](https://api-docs.deepseek.com/guides/thinking_mode)
-   [vLLM 文档，推理输出：reasoning 字段（原 reasoning\_content）、thinking\_token\_budget（2026-11-15 核对）](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
