BroadRouter

max_tokens для моделей с рассуждениями: как рассчитать бюджет

Команда BroadNet Inference · 6 мин чтения · Опубликовано

У модели с рассуждениями max_tokens ограничивает рассуждения и ответ вместе, поэтому тесный лимит может оборвать ответ раньше, чем появится видимый текст. Измерьте общее число выходных токенов по каждому типу задач, задайте max_tokens около 95-го перцентиля плюс 20%, держите промпт вместе с max_tokens в пределах контекстного окна и повторяйте оборванные ответы с удвоенным бюджетом до жёсткого потолка.

Модель с рассуждениями думает, прежде чем ответить, и в большинстве OpenAI-совместимых API рассуждения и ответ расходуют один бюджет — max_tokens. Задайте его так, как для модели без рассуждений, — несколько сотен токенов на короткий ответ, — и часть ответов придёт пустой с finish_reason: "length". Быстрое исправление описано в руководстве почему модель с рассуждениями возвращает пустой ответ. А эта статья — о методе, который даёт бюджет, которому можно доверять: измерить, рассчитать по перцентилям, учесть контекстное окно и обработать ответы, которые всё-таки обрываются.

О том, сколько стоят рассуждения и как сократить расходы на них, читайте в статье токены рассуждений: почему вы платите за больший вывод, чем видите.

Почему бюджет заканчивается раньше ответа?

Модель генерирует по порядку: сначала рассуждения, потом видимый ответ. Каждый токен и того и другого засчитывается в 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» (перевод: «включая видимые выходные токены и токены рассуждений»).

Поэтому правильный вопрос — не «какой длины мой ответ?», а «какой длины рассуждения и ответ вместе на этой задаче при этом уровне усилий?» Разброс тут больше, чем обычно ожидают. Руководство OpenAI говорит, что её модели могут генерировать «anywhere from a few hundred to tens of thousands of reasoning tokens» (перевод: «от нескольких сотен до десятков тысяч токенов рассуждений») в зависимости от задачи.

Стоит ли больший max_tokens дороже?

Нет. И это самая частая причина, по которой бюджеты ставят слишком тесными. max_tokens — это потолок. Вы платите за реально сгенерированные токены. Ответ, которому нужно 1800 токенов, стоит одинаково при потолке 4000 и 40 000.

А вот чего стоит тесный потолок:

Потолок и потребность Что вы платите Что получаете
Потолок выше потребности Сгенерированные токены Ответ
Потолок ниже потребности Весь потолок, целиком на рассуждения Ничего полезного, плюс повторный запрос

Возьмём пример. Допустим, четверти ваших вызовов нужно больше 1000 токенов. При max_tokens=1000 каждый такой вызов оплачивает 1000 выходных токенов рассуждений, ничего не возвращает и повторяется. Это в среднем 250 впустую потраченных выходных токенов на каждый вызов по всем вызовам — ещё до самих повторов, плюс задержка второго запроса. При потолке 4000 ничего не теряется. На Qwen3.8 27B выход стоит $2.17 за 1 млн токенов, так что на объёме потери накапливаются.

Настоящий риск высокого потолка — неуправляемый ответ: модель зацикливается или слишком долго думает и генерирует гораздо больше нужного. Жёсткий потолок это ограничивает. Выбирайте его по данным, как описано ниже.

Как измерить, сколько нужно задаче?

Прогоните реальные промпты одного типа задач со щедрым потолком и запишите число выходных токенов и долю рассуждений. Если модель её сообщает, usage.completion_tokens_details.reasoning_tokens даёт часть, ушедшую на рассуждения; это поле есть в документации BroadNet.

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. Перезапускайте при смене модели или промпта. Новая версия модели может думать больше или меньше.

Затем задайте max_tokens для каждой задачи по recommend(). 95-й перцентиль плюс 20% оставляет большинство вызовов заметно ниже потолка и отправляет на описанный ниже путь повтора лишь редкие длинные ответы. Бесплатный калькулятор бюджета токенов рассуждений проделает эту арифметику в браузере, когда у вас будут свои цифры.

Как контекстное окно ограничивает бюджет?

Контекстное окно вмещает промпт и ответ вместе. Прайс-фид BroadNet определяет context_length как «the most tokens one request can hold, prompt and answer together» (перевод: «наибольшее число токенов, которое вмещает один запрос, промпт и ответ вместе»). Отсюда:

max_tokens ≤ длина контекста − токены промпта

Модель Контекст Место для max_tokens при промпте в 200 000 токенов
GLM 5.3 1 048 576 848 576
DeepSeek V4.1 Flash 1 048 576 848 576
Qwen3.8 27B 262 144 62 144

Это важно для работы с длинным контекстом. У агента, чья история на Qwen3.8 27B разрослась до 250 000 токенов, остаётся всего около 12 000 токенов на рассуждения и ответ. Задачи с длинным контекстом к тому же обычно требуют больше рассуждений, так что проверяйте остаток места в момент вызова, а не один раз при старте. Подробности — в статье о контекстном окне и в калькуляторе контекстного окна.

Что делать, если ответ всё равно обрывается?

Проверяйте finish_reason в каждом вызове. Если он равен length, ответа нет или он неполный, даже если в content есть какой-то текст. Не разбирайте его как завершённый: обрезанный JSON-объект — частый источник ошибок дальше по цепочке (структурированный вывод).

Повторяйте с удвоенным бюджетом в пределах места, которое оставляет контекст, до жёсткого потолка:

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" при том же бюджете. На простых задачах модель часто слишком много думает, и меньшее усилие решает проблему без увеличения потолка.
  • Разбейте задачу. Если ответ раз за разом упирается в высокий потолок, запрос обычно требует слишком много за один раз.

Логируйте каждый обрыв вместе с типом задачи. Растущая доля обрывов означает, что изменились промпт, модель или входные данные, и бюджет нужно измерить заново. Повторы — это новые инференсы, и они оплачиваются снова, так что ограничивайте число попыток, как в статье долгие агенты: таймауты и повторы.

Что меняет стриминг?

С stream=True рассуждения идут до первого видимого токена, поэтому модель с рассуждениями в начале может казаться зависшей. В чат-интерфейсе показывайте состояние «думает», пока не придёт контент, и рассчитывайте клиентские таймауты с учётом времени на рассуждения, а не только на ответ.

Некоторые серверы стримят и сам текст рассуждений в отдельном поле. Его название не стандартизовано: собственный API DeepSeek использует reasoning_content, а vLLM переименовал поле из reasoning_content в reasoning, предупредив, что старый клиентский код «could silently read an empty» (перевод: «может молча читать пустое») поле. В документации BroadNet поле с текстом рассуждений не описано, так что не стройте на нём функции, не проверив сырой ответ своей модели. Если всё же читаете его, делайте это осторожно:

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 это документирует. Больше о потоках — в руководстве по стримингу и в статье SSE простыми словами.

Какое имя параметра отправлять?

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 Да

Перенося код между провайдерами, отправляйте то имя, которое документирует провайдер, и одним тестовым вызовом убедитесь, что лимит действует. Молча проигнорированный лимит выглядит нормально, пока не придёт неуправляемый ответ. Остальные параметры, которые меняются при переезде, описаны в чек-листе миграции.

Где здесь BroadNet Inference

Три модели BroadNet с рассуждениями сообщают токены рассуждений в usage, когда модель их предоставляет, так что описанное выше измерение работает как есть. Больше всего места дают DeepSeek V4.1 Flash и GLM 5.3 — 1 048 576 токенов контекста. У Qwen3.8 27B — 262 144. Если задаче рассуждения не нужны, Gemma 4 VL 26B не значится моделью с рассуждениями и вообще снимает вопрос бюджета. На фиксированном тарифе DeepSeek V4.1 Flash за токены рассуждений не берётся плата за токен, но оборванные ответы всё равно стоят времени, так что то же планирование бюджета применимо и там. Отдельного лимита на рассуждения BroadNet не документирует; если он вам нужен, используйте провайдера или собственный сервер, который его предлагает.

Вопросы и ответы

Почему модель с рассуждениями возвращает пустой ответ?

Модель потратила весь бюджет max_tokens на скрытые рассуждения, не успев написать ответ. finish_reason в таком случае равен «length». Увеличьте max_tokens, понизьте reasoning_effort или сделайте и то и другое. Короткое руководство с быстрым исправлением есть по ссылке в этой статье.

Какой max_tokens ставить для модели с рассуждениями?

Сначала измерьте. Прогоните 50 или больше реальных промптов со щедрым потолком, возьмите 95-й перцентиль completion_tokens для этой задачи и добавьте около 20%. Документация BroadNet называет минимум в 1000 токенов или больше; OpenAI советует на старте резервировать 25 000 для своих моделей.

Стоит ли больший max_tokens дороже?

Сам по себе нет. Вы платите за токены, которые сгенерировала модель, а не за потолок. Более высокий потолок обходится дороже, только когда ответ иначе был бы оборван, — а оборванный ответ всё равно стоил бы вам повторного запроса.

max_completion_tokens и max_tokens — это одно и то же?

У OpenAI max_completion_tokens заменяет устаревший max_tokens и явно включает токены рассуждений. Многие OpenAI-совместимые провайдеры вместо него документируют max_tokens. В документации BroadNet используется max_tokens, и сказано, что рассуждения в него входят.

Можно ли ограничить рассуждения отдельно от ответа?

Только там, где это поддерживает сервер. У vLLM есть параметр thinking_token_budget, у некоторых провайдеров — свои. BroadNet документирует reasoning_effort со значением low, а не отдельный лимит на рассуждения, так что планируйте бюджет на оба сразу.

Открыть в MarkdownСпросить ChatGPTСпросить ClaudeСпросить Perplexity