Nag-iisip muna ang reasoning model bago sumagot, at sa karamihan ng OpenAI-compatible na API, iisang budget ang pinanggagalingan ng dalawa: max_tokens. Kapag itinakda mo ito gaya ng sa non-reasoning model, ilang daang token para sa maikling sagot, may mga reply na babalik nang walang laman at may finish_reason: "length". Nasa bakit walang laman ang sagot ng reasoning model ang mabilis na solusyon. Ang post na ito ang paraan sa likod ng budget na mapagkakatiwalaan mo: sukatin, itakda mula sa percentile, igalang ang context window, at hawakan ang mga reply na naputol pa rin.
Para sa gastos ng reasoning at kung paano ito babawasan, tingnan ang reasoning token: bakit mas maraming output ang binabayaran mo kaysa nakikita mo.
Bakit nauubos ang budget bago ang sagot?
Sunod-sunod ang pagbuo ng model: una ang reasoning nito, saka ang nakikitang sagot. Bawat token ng dalawa ay kasama sa max_tokens. Ito ang sinasabi ng docs ng BroadNet para sa DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B: “the reasoning counts toward max_tokens” (salin: kasama ang reasoning sa max_tokens), at kapag maliit ang limit, “the answer comes back empty” (salin: walang laman ang bumabalik na sagot). Ganoon din ang depinisyon ng reference ng OpenAI Chat Completions sa max_completion_tokens, bilang upper bound “including visible output tokens and reasoning tokens” (salin: kasama ang nakikitang output token at reasoning token).
Kaya ang dapat itanong ay hindi “gaano kahaba ang sagot ko?” Ito ay “gaano kahaba ang reasoning at sagot nang magkasama, sa task na ito, sa effort na ito?” Mas pabago-bago iyan kaysa inaasahan ng marami. Sabi ng guide ng OpenAI, puwedeng bumuo ang mga model nito ng “anywhere from a few hundred to tens of thousands of reasoning tokens” (salin: mula ilang daan hanggang sampu-sampung libong reasoning token), depende sa problema.
Mas mahal ba kapag mas malaki ang max_tokens?
Hindi. Ito ang pinakakaraniwang dahilan kung bakit masyadong masikip ang itinatakdang budget. Kisame ang max_tokens. Ang talagang nabuong token ang sinisingil sa iyo. Pareho ang gastos ng reply na nangangailangan ng 1,800 token kahit 4,000 o 40,000 ang kisame.
Ito ang talagang gastos ng masikip na kisame:
| Kisame vs kailangan | Binabayaran mo | Nakukuha mo |
|---|---|---|
| Kisame na lampas sa kailangan | Mga token na nabuo | Ang sagot |
| Kisame na kulang sa kailangan | Ang buong kisame, puro reasoning | Walang magagamit, dagdag pa ang retry |
Halimbawa: ipagpalagay na isang-kapat ng mga tawag mo ang nangangailangan ng higit 1,000 token. Sa max_tokens=1000, sinisingil ang bawat isa sa mga tawag na iyon ng 1,000 output token ng pag-iisip, walang ibinabalik, at nire-retry. Nagdaragdag iyan ng 250 nasayang na output token kada tawag sa karaniwan sa lahat ng tawag, bago pa ang mga retry mismo, dagdag ang latency ng ikalawang request. Kapag 4,000 ang kisame, walang nasasayang. Sa Qwen3.8 27B, $2.17 kada 1M token ang output, kaya lumalaki ang sayang kapag malaki ang volume.
Ang totoong panganib ng mataas na kisame ay ang runaway na reply: model na umiikot o sobra mag-isip at bumubuo ng higit pa sa kailangan. Hard cap ang pumipigil diyan. Piliin ang cap mula sa data, gaya ng nasa ibaba.
Paano sukatin ang kailangan ng isang task?
Magpatakbo ng totoong prompt para sa isang uri ng task na may maluwag na kisame, at itala ang completion token at ang bahagi ng reasoning. Kapag iniuulat ito ng model, ibinibigay ng usage.completion_tokens_details.reasoning_tokens ang bahagi ng reasoning; nakalista ang field na iyon sa docs ng 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")))
Mga patakaran para sa numerong mapagkakatiwalaan:
- Isang uri ng task kada run. Magkakaibang-magkaiba ang distribution ng classification, extraction, code review at planning. Ang iisang pangkalahatang
max_tokensay nagsasayang ng pera sa retry o nagpapalusot ng runaway na reply. - 50 o higit pang totoong prompt. Ang 95th percentile ng sampung sample ay ang pinakamalaki lang sa mga iyon.
- Patakbuhin ito sa bawat effort na ginagamit mo. Binabago ng
reasoning_effort="low"ang distribution.lowang dinodokumento ng BroadNet; i-test ang ibang value bago umasa sa mga iyon. - Kung hindi zero ang
cut_off, itaas ang kisame at patakbuhin ulit. Itinatago ng naputol na sample ang totoong haba nito. - Patakbuhin ulit kapag nagbago ang model o prompt. Puwedeng mas marami o mas kaunti ang pag-iisip ng bagong bersyon ng model.
Pagkatapos, itakda ang max_tokens kada task mula sa recommend(). Sa 95th percentile dagdag 20%, malayo sa kisame ang karamihan ng tawag, at ang paminsan-minsang mahaba lang ang napupunta sa retry path sa ibaba. Ang libreng reasoning token budget tool ang gagawa ng kuwentang ito sa browser mo kapag hawak mo na ang mga numero mo.
Paano nililimitahan ng context window ang budget?
Magkasama sa context window ang prompt at ang sagot. Ganito ang depinisyon ng price feed ng BroadNet sa context_length: “the most tokens one request can hold, prompt and answer together” (salin: ang pinakamaraming token na kayang hawakan ng isang request, prompt at sagot nang magkasama). Kaya:
max_tokens ≤ context length − prompt token
| Model | Context | Puwang para sa max_tokens kapag 200,000 token ang prompt |
|---|---|---|
| GLM 5.3 | 1,048,576 | 848,576 |
| DeepSeek V4.1 Flash | 1,048,576 | 848,576 |
| Qwen3.8 27B | 262,144 | 62,144 |
Mahalaga ito sa long-context na trabaho. Ang agent na umabot na sa 250,000 token ang history sa Qwen3.8 27B ay may mga 12,000 token na lang para sa pag-iisip at sagot. Kadalasang mas maraming reasoning din ang kailangan ng long-context na task, kaya tingnan ang natitirang puwang sa mismong oras ng tawag, hindi minsan lang sa startup. Sinasaklaw ng context window at ng context window calculator ang pagkakasya.
Ano ang gagawin kapag naputol pa rin ang reply?
Tingnan ang finish_reason sa bawat tawag. Kung length ito, kulang o hindi kumpleto ang sagot, kahit may text ang content. Huwag itong i-parse na parang kumpleto; karaniwang pinagmumulan ng error sa susunod na hakbang ang naputol na JSON object (structured output).
Mag-retry nang dinobleng budget, sa loob ng puwang na pinapayagan ng context, hanggang sa isang hard cap:
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
Dalawang alternatibo sa pagdodoble, depende sa task:
- Mag-retry sa
reasoning_effort="low"na pareho ang budget. Sa mga simpleng task, madalas sobra mag-isip ang model, at naaayos ito ng mas mababang effort nang hindi kailangan ng mas malaking kisame. - Hatiin ang task. Kung paulit-ulit na tumatama sa mataas na cap ang isang reply, kadalasang sobra ang hinihingi ng request nang sabay-sabay.
I-log ang bawat pagkaputol kasama ang uri ng task. Kapag tumataas ang rate, may nagbago sa prompt, sa model o sa input data, at kailangang sukatin ulit ang budget. Bagong inference ang mga retry at sinisingil ulit, kaya limitahan ang bilang ng subok, gaya ng sa long-running agent: timeout at retry.
Paano binabago ng streaming ang sitwasyon?
Sa stream=True, nangyayari ang reasoning bago ang unang nakikitang token, kaya puwedeng mukhang natigil ang reasoning model sa simula. Sa chat UI, magpakita ng “thinking” na estado hanggang dumating ang content, at itakda ang client timeout para sa oras ng pag-iisip, hindi lang sa sagot.
May mga server din na nag-i-stream ng mismong reasoning text, sa hiwalay na field. Hindi standard ang pangalan: reasoning_content ang gamit ng sariling API ng DeepSeek, at pinalitan ng vLLM ang pangalan ng field nito mula reasoning_content tungong reasoning, na may babalang ang lumang client code ay “could silently read an empty” field (salin: puwedeng tahimik na makabasa ng walang lamang field). Hindi dinodokumento ng docs ng BroadNet ang isang reasoning text field, kaya huwag bumuo ng feature dito nang hindi tinitingnan ang raw response para sa model mo. Kung babasahin mo ito, basahin nang maingat:
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))
Kailangan ng stream_options={"include_usage": True} ang usage sa huling chunk, at dinodokumento ito ng BroadNet. Higit pa tungkol sa stream sa streaming guide at sa paliwanag sa SSE.
Aling pangalan ng parameter ang dapat mong ipadala?
| API | Parameter | Kasama ang reasoning |
|---|---|---|
| OpenAI Chat Completions | max_completion_tokens (deprecated ang max_tokens) |
Oo |
| OpenAI Responses | max_output_tokens |
Oo |
| BroadNet Inference (Chat Completions) | max_tokens, ayon sa docs |
Oo |
| Mga vLLM server | max_tokens, dagdag ang opsyonal na thinking_token_budget |
Oo |
Kapag naglilipat ng code sa pagitan ng mga provider, ipadala ang pangalang dinodokumento ng provider, at kumpirmahin sa isang test call na gumagana ang limit. Mukhang ayos ang limit na tahimik na binabalewala hanggang may dumating na runaway na reply. Sinasaklaw ng migration checklist ang iba pang parameter na nagbabago.
Saan pumapasok ang BroadNet Inference
Iniuulat ng tatlong reasoning model ng BroadNet ang reasoning token sa usage kapag ibinibigay ito ng model, kaya gumagana ang pagsukat sa itaas gaya ng pagkakasulat. Ang DeepSeek V4.1 Flash at GLM 5.3 ang nagbibigay ng pinakamaraming puwang, na may 1,048,576 token na context. 262,144 ang sa Qwen3.8 27B. Kung hindi mo kailangan ng reasoning para sa isang task, hindi nakalista bilang reasoning model ang Gemma 4 VL 26B at naiiwasan nito ang tanong sa budget. Sa flat na DeepSeek V4.1 Flash plan, walang singil kada token ang mga thinking token, pero may gastos pa rin sa oras ang mga naputol na reply, kaya parehong pag-budget ang naaangkop. Hindi dinodokumento ng BroadNet ang hiwalay na limit sa reasoning; kung kailangan mo nito, gumamit ng provider o self-hosted na server na nag-aalok nito.
