Naputol ang sagot ng AI? Ayusin ang finish_reason "length" at max_tokens

Tumakbo ang script mo, sumagot ang modelo, at natapos ang function sa gitna ng linya. O nag-throw ang JSON parser sa isang reply na mukhang normal. Kadalasan, hindi nag-fail ang modelo: naabot nito ang max_tokens limit na itinakda mo (o isang default na hindi mo nakita) at hininto ito ng API sa gitna ng salita.

Ang mabilis na fix: basahin ang finish_reason sa response. Kung ito ay "length" (OpenAI-compatible API) o stop_reason ay "max_tokens" (Anthropic Messages), naputol ang sagot. Itaas ang max_tokens hanggang sa output limit ng modelo, o hilingin sa modelo na magpatuloy. Ang natitirang bahagi ng pahinang ito ay nagpapakita ng dalawa sa code na maaari mong i-paste.

Kung gusto mo ang simpleng paliwanag kung bakit nangyayari ito, magsimula sa bakit humihinto ang sagot ng AI sa gitna ng pangungusap. Ang pahinang ito ay ang debugging version.

Paano lumalabas sa screen ang putol na sagot#

Nag-iiba ang sintomas depende sa hiniling mo, pero pareho ang dahilan. Subukang itugma ang mga ito sa nakita mo:

Mahalaga ang huling row. Kung ang finish_reason ay stop, hindi ang limit ang problema mo, at walang mababago ang pagtaas ng max_tokens.

Hakbang 1: basahin ang field na nagsasabi sa iyo#

Sinasabi ng bawat response kung bakit natapos ang generation. Sa OpenAI-compatible response ito ay choices[0].finish_reason: "stop" kapag natapos ang modelo, "length" kapag naubos ang tokens. Sa Anthropic Messages API ang field ay stop_reason, at ang cut-off value ay "max_tokens". Inirerekomenda ng stop-reason guide ng Anthropic (sinuri noong 28 Oktubre 2026) ang eksaktong dalawang fix sa ibaba: itaas ang max_tokens o ipagpatuloy ang response.

Narito ang parehong check sa tatlong anyo. Ang base URL ay https://api.cheaptokens.dev/v1 para sa OpenAI SDK at https://api.cheaptokens.dev (walang /v1) para sa Anthropic SDK. Ang max_tokens=200 ay sadyang maliit, para makita mo mismo ang putol.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    max_tokens=200,
    messages=[{"role": "user", "content": "Write a Python class for a todo list with tests."}],
)

choice = resp.choices[0]
if choice.finish_reason == "length":
    print("Cut off at the token limit")
print(choice.message.content)
print(resp.usage.completion_tokens)

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.cheaptokens.dev",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

msg = client.messages.create(
    model="deepseek-ai/DeepSeek-V4-Flash-0731",
    max_tokens=200,
    messages=[{"role": "user", "content": "Write a Python class for a todo list with tests."}],
)

if msg.stop_reason == "max_tokens":
    print("Cut off at the token limit")
print(msg.content[0].text)

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "max_tokens": 200,
    "messages": [{"role": "user", "content": "Write a Python class for a todo list with tests."}]
  }'

Kapag gumana ito bilang diagnosis, makikita mo ang pares na ito: ang mababang limit ay nagbibigay ng length, ang maluwag na limit ay nagbibigay ng stop.

Hakbang 2: itaas ang max_tokens, pero huwag lumampas sa ceiling#

Ang halatang fix ay mas malaking numero. Ang catch: may sariling cap ang bawat modelo sa sagot. Huwag magtakda ng value na lampas dito: per model ang limit, kaya tingnan muna ang table sa ibaba. Ito ang per-answer limits sa CheapTokens (facts checked 28 October 2026):

Ang 9,000-token translation ay nangangailangan ng model na may mas malaking per-answer limit — ang DeepSeek-V4-Flash ay tumatanggap ng hanggang 32,768 tokens per answer. Para sa mahabang code, mahabang JSON o buong dokumento, ang deepseek-ai/DeepSeek-V4-Flash-0731 ang may pinakamaraming espasyo: hanggang 32,768 tokens per answer, isang presyo sa anumang oras ng araw. Kunin ang eksaktong model ids mula sa CheapTokens docs at sa models page, dahil iba-iba ang pagpangalan ng mga provider.

Isang praktikal na tuntunin: itakda ang max_tokens sa pinakamahabang sagot na tatanggapin mo, hindi sa maximum. Nagbabayad ka para sa tokens na aktwal na isinusulat ng modelo, kaya walang gastos ang mataas na ceiling kapag maikli ang mga sagot.

Hakbang 3: JSON na humihinto sa gitna#

Ang putol na JSON reply ang pinakamahirap na kaso, dahil mukhang tama ang teksto hanggang maabot ng parser ang dulo. Sabihin nating nag-extract ka ng fields mula sa 40 invoice sa isang call at humingi ng array. Nagsulat ang modelo ng 31 object, naabot ang limit, at hindi kailanman nagsara ang array.

Huwag subukang ayusin ang string sa pamamagitan ng pagdaragdag ng ]}. Makakakuha ka ng valid JSON na may kulang na records, na mas masama kaysa sa error. Tingnan muna ang finish_reason; kung ito ay length, maaaring itaas ang limit at i-rerun ang call, o hatiin ang input sa mas maliliit na batch. Para sa pagpilit ng format mismo, tingnan ang valid JSON mula sa LLM API.

Hakbang 4: hayaan ang modelo na magpatuloy#

Minsan, talagang mas mahaba ang sagot kaysa sa anumang limit: isang kabanata ng libro, isang malaking refactor. Pagkatapos, ibalik ang mayroon ka at hilingin sa modelo na magpatuloy. Ang loop sa ibaba ay pinapanatili ang tekstong mayroon na, humihingi ng natitira, at sumusuko pagkatapos ng ilang round para hindi umikot nang walang hanggan ang isang bug.

def complete(base_messages, model, max_tokens=4096, rounds=4):
    text = ""
    for _ in range(rounds):
        messages = list(base_messages)
        if text:
            messages += [
                {"role": "assistant", "content": text},
                {"role": "user", "content": "Continue exactly where you stopped. Do not repeat anything."},
            ]
        r = client.chat.completions.create(model=model, max_tokens=max_tokens, messages=messages)
        choice = r.choices[0]
        text += choice.message.content or ""
        if choice.finish_reason != "length":
            return text, True   # finished on its own
    return text, False          # still cut after all rounds

Dalawang ugali ang nagpapanatili nitong tapat. Ibalik ang True/False flag at magpakita ng warning sa user kapag False, sa halip na ipresenta ang kalahating dokumento na parang tapos na. At tandaan na bawat round ay muling ipinapadala ang naunang teksto bilang input, kaya mas mahal ang continued answer kaysa sa isang malaking sagot. Para sa structured data, mas mainam ang mas malaking limit o mas maliliit na batch kaysa sa pagpapatuloy.

Magkano ang gastos ng mahabang sagot#

Sabihin nating ang isang mahabang sagot ay 2,000 tokens in at 8,000 tokens out. Sa DeepSeek-V4-Flash, ang request na iyon ay nagkakahalaga ng $0.00083 sa presyo ngayon, at sa kabuuan, kasama ang input at output, mas mura ito kaysa sa OpenRouter. Palitan ang mga numero ng sarili mong load:

Ang takeaway: nangingibabaw ang output side sa senaryong ito, kaya ang headroom sa max_tokens ay murang insurance laban sa rerun. Ang putol na sagot na kailangan mong i-regenerate ay binabayaran nang dalawang beses. Ang background sa dalawang bahagi ng bill ay nasa input vs output tokens, at ang buong listahan ng modelo na may presyo ay nasa pricing page.

Bago ka mag-ship: maikling checklist#