Model penalaran berpikir sebelum menjawab, dan di sebagian besar API kompatibel OpenAI keduanya diambil dari satu anggaran: max_tokens. Jika Anda mengaturnya seperti untuk model non-penalaran, beberapa ratus token untuk jawaban singkat, sebagian balasan akan kembali kosong dengan finish_reason: "length". Perbaikan cepatnya ada di kenapa model penalaran mengembalikan jawaban kosong. Artikel ini membahas metode di balik anggaran yang bisa diandalkan: ukur, tentukan dari persentil, patuhi context window, dan tangani balasan yang masih terpotong.
Untuk biaya penalaran dan cara menguranginya, lihat token penalaran: kenapa Anda membayar output lebih banyak dari yang terlihat.
Kenapa anggaran habis sebelum jawaban keluar?
Model menghasilkan secara berurutan: pertama penalarannya, lalu jawaban yang terlihat. Setiap token dari keduanya dihitung dalam max_tokens. Dokumentasi BroadNet menyatakan ini untuk DeepSeek V4.1 Flash, GLM 5.3, dan Qwen3.8 27B: “the reasoning counts toward max_tokens” (Terjemahan BroadRouter: penalaran dihitung dalam max_tokens), dan dengan batas kecil “the answer comes back empty” (Terjemahan BroadRouter: jawabannya kembali kosong). Referensi Chat Completions OpenAI mendefinisikan max_completion_tokens dengan cara yang sama, sebagai batas atas “including visible output tokens and reasoning tokens” (Terjemahan BroadRouter: termasuk token output yang terlihat dan token penalaran).
Jadi pertanyaannya bukan “seberapa panjang jawaban saya?” melainkan “seberapa panjang penalaran dan jawaban sekaligus, untuk tugas ini, pada effort ini?” Variasinya lebih besar dari yang diperkirakan orang. Panduan OpenAI menyebutkan model-modelnya bisa menghasilkan “anywhere from a few hundred to tens of thousands of reasoning tokens” (Terjemahan BroadRouter: mulai dari beberapa ratus hingga puluhan ribu token penalaran), tergantung masalahnya.
Apakah max_tokens yang lebih besar lebih mahal?
Tidak. Inilah alasan paling umum anggaran diatur terlalu ketat. max_tokens adalah plafon. Anda ditagih untuk token yang benar-benar dihasilkan. Balasan yang butuh 1.800 token biayanya sama, baik plafonnya 4.000 maupun 40.000.
Yang membuat plafon ketat memakan biaya:
| Plafon vs kebutuhan | Yang Anda bayar | Yang Anda dapat |
|---|---|---|
| Plafon di atas kebutuhan | Token yang dihasilkan | Jawabannya |
| Plafon di bawah kebutuhan | Seluruh plafon, semuanya penalaran | Tidak ada yang bisa dipakai, plus retry |
Ambil ilustrasi. Misalkan seperempat panggilan Anda butuh lebih dari 1.000 token. Dengan max_tokens=1000, setiap panggilan itu menagih 1.000 token output berupa proses berpikir, tidak mengembalikan apa pun, lalu diulang. Itu menambah rata-rata 250 token output terbuang per panggilan di seluruh panggilan, belum termasuk retry-nya sendiri, plus latensi permintaan kedua. Dengan plafon 4.000, tidak ada yang terbuang. Di Qwen3.8 27B, output seharga $2.17 per 1 juta token, jadi pemborosan ini menumpuk pada volume besar.
Risiko sebenarnya dari plafon tinggi adalah balasan yang lepas kendali: model yang berputar-putar atau berpikir berlebihan dan menghasilkan jauh lebih banyak dari yang dibutuhkan. Batas keras membatasinya. Tentukan batas itu dari data, seperti di bawah.
Bagaimana mengukur kebutuhan sebuah tugas?
Jalankan prompt nyata untuk satu jenis tugas dengan plafon yang longgar, lalu catat completion token dan porsi penalarannya. Jika model melaporkannya, usage.completion_tokens_details.reasoning_tokens memberi bagian penalaran; dokumentasi BroadNet mencantumkan field itu.
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")))
Aturan agar angkanya bisa diandalkan:
- Satu jenis tugas per run. Klasifikasi, ekstraksi, code review, dan perencanaan punya distribusi yang sangat berbeda. Satu
max_tokensglobal entah membuang uang untuk retry atau meloloskan balasan yang lepas kendali. - 50 atau lebih prompt nyata. Persentil ke-95 dari sepuluh sampel hanyalah sampel terbesar.
- Jalankan di setiap tingkat effort yang Anda pakai.
reasoning_effort="low"mengubah distribusinya. BroadNet mendokumentasikanlow; uji nilai lain sebelum Anda mengandalkannya. - Jika
cut_offtidak nol, naikkan plafon dan jalankan lagi. Sampel yang terpotong menyembunyikan panjang sebenarnya. - Jalankan ulang saat model atau prompt berubah. Versi model baru bisa berpikir lebih banyak atau lebih sedikit.
Lalu atur max_tokens per tugas dari recommend(). Persentil ke-95 ditambah 20% membuat sebagian besar panggilan jauh di bawah plafon dan hanya mengirim panggilan panjang yang jarang ke jalur retry di bawah. Alat anggaran token penalaran yang gratis menghitungnya di browser Anda begitu angkanya sudah ada.
Bagaimana context window membatasi anggaran?
Context window menampung prompt dan jawaban sekaligus. Feed harga BroadNet mendefinisikan context_length sebagai “the most tokens one request can hold, prompt and answer together” (Terjemahan BroadRouter: jumlah token terbanyak yang bisa ditampung satu permintaan, prompt dan jawaban sekaligus). Jadi:
max_tokens ≤ panjang context − token prompt
| Model | Context | Ruang untuk max_tokens dengan prompt 200.000 token |
|---|---|---|
| GLM 5.3 | 1.048.576 | 848.576 |
| DeepSeek V4.1 Flash | 1.048.576 | 848.576 |
| Qwen3.8 27B | 262.144 | 62.144 |
Ini penting untuk pekerjaan konteks panjang. Agent yang riwayatnya sudah tumbuh hingga 250.000 token di Qwen3.8 27B hanya punya sekitar 12.000 token tersisa untuk berpikir dan menjawab. Tugas konteks panjang juga cenderung butuh penalaran lebih banyak, jadi periksa sisa ruangnya saat panggilan dilakukan, bukan sekali saat startup. Context window dan kalkulator context window membahas soal muat tidaknya.
Apa yang harus dilakukan jika balasan masih terpotong?
Periksa finish_reason di setiap panggilan. Jika nilainya length, jawabannya hilang atau tidak lengkap, meskipun content berisi sedikit teks. Jangan mem-parse-nya seolah lengkap; objek JSON yang terpotong adalah sumber error hilir yang umum (output terstruktur).
Ulangi dengan anggaran dua kali lipat, dalam ruang yang diizinkan context, hingga batas keras:
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
Dua alternatif selain menggandakan, tergantung tugasnya:
- Ulangi dengan
reasoning_effort="low"pada anggaran yang sama. Untuk tugas sederhana, model sering berpikir berlebihan, dan effort yang lebih rendah menyelesaikannya tanpa plafon yang lebih besar. - Pecah tugasnya. Jika sebuah balasan terus menabrak batas yang tinggi, biasanya permintaannya meminta terlalu banyak sekaligus.
Catat setiap pemotongan beserta jenis tugasnya di log. Tingkat yang naik berarti prompt, model, atau data input berubah, dan anggarannya perlu diukur ulang. Retry adalah inferensi baru dan ditagih lagi, jadi batasi jumlah percobaannya, seperti di agent yang berjalan lama: timeout dan retry.
Bagaimana streaming mengubah gambarannya?
Dengan stream=True, penalaran terjadi sebelum token pertama yang terlihat, sehingga model penalaran bisa tampak macet di awal. Di UI chat, tampilkan status “sedang berpikir” sampai konten tiba, dan atur timeout klien untuk waktu berpikir, bukan hanya untuk jawabannya.
Beberapa server juga men-stream teks penalaran itu sendiri, di field terpisah. Namanya tidak standar: API DeepSeek sendiri memakai reasoning_content, dan vLLM mengganti nama field-nya dari reasoning_content menjadi reasoning, dengan peringatan bahwa kode klien lama “could silently read an empty” (Terjemahan BroadRouter: bisa diam-diam membaca field kosong). Dokumentasi BroadNet tidak mendokumentasikan field teks penalaran, jadi jangan membangun fitur di atasnya tanpa memeriksa respons mentah untuk model Anda. Jika Anda membacanya, baca secara defensif:
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 di chunk terakhir memerlukan stream_options={"include_usage": True}, yang didokumentasikan BroadNet. Lebih lanjut tentang stream ada di panduan streaming dan penjelasan SSE.
Nama parameter mana yang harus dikirim?
| API | Parameter | Termasuk penalaran |
|---|---|---|
| OpenAI Chat Completions | max_completion_tokens (max_tokens deprecated) |
Ya |
| OpenAI Responses | max_output_tokens |
Ya |
| BroadNet Inference (Chat Completions) | max_tokens, sesuai dokumentasi |
Ya |
| Server vLLM | max_tokens, plus thinking_token_budget opsional |
Ya |
Saat memindahkan kode antarpenyedia, kirim nama yang didokumentasikan penyedia, dan pastikan dengan satu panggilan uji bahwa batasnya berlaku. Batas yang diam-diam diabaikan terlihat baik-baik saja sampai balasan yang lepas kendali muncul. Checklist migrasi membahas parameter lain yang berubah.
Di mana posisi BroadNet Inference?
Tiga model penalaran BroadNet melaporkan token penalaran di usage jika model menyediakannya, sehingga pengukuran di atas berjalan sebagaimana tertulis. DeepSeek V4.1 Flash dan GLM 5.3 memberi ruang paling besar, dengan context 1.048.576 token. Qwen3.8 27B punya 262.144. Jika Anda tidak butuh penalaran untuk suatu tugas, Gemma 4 VL 26B tidak tercantum sebagai model penalaran dan menghindari persoalan anggaran ini sama sekali. Pada paket DeepSeek V4.1 Flash harga tetap, token berpikir tidak dikenai biaya per token, tetapi balasan yang terpotong tetap membuang waktu, jadi penganggaran yang sama tetap berlaku. BroadNet tidak mendokumentasikan batas penalaran terpisah; jika Anda membutuhkannya, gunakan penyedia atau server self-hosted yang menawarkannya.
