---
title: "Invalid JSON mula sa LLM: sanhi, repair at retry | BroadRouter"
description: "Bakit sirang JSON ang ibinabalik ng LLM (code fence, prose, naputol sa max_tokens, trailing comma) at isang tested na Python function na nag-aayos lang ng ligtas."
url: https://broadrouter.com/fil/blog/fix-invalid-json-from-llm/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/fix-invalid-json-from-llm/) (na-update noong 2026-11-16).

# Paano ayusin ang invalid JSON mula sa LLM: sanhi, repair, retry

Ng BroadNet Inference team · 7 minutong basa · Nailathala 2026-11-15 · Na-update 2026-11-16

Tingnan muna ang finish\_reason: hindi ligtas na maaayos ang sagot na naputol sa max\_tokens, kaya taasan ang limit at ipadala ulit. Kung hindi, alisin ang code fence at nakapalibot na prose, i-decode ang unang JSON value, at ayusin lang ang malinaw na mali gaya ng trailing comma. I-validate laban sa schema, at kung pumalya, ibalik nang isa o dalawang beses ang eksaktong error. Kung suportado, napipigilan ng structured output ang karamihan nito.

## Mga pangunahing punto

-   Pagbabalot ang karamihan ng sirang JSON, hindi maling JSON: code fence, pangungusap bago o pagkatapos, o reasoning block. Binabasa ng raw\_decode ng Python ang unang value at hindi pinapansin ang iba.
-   Ang finish\_reason na "length" ay nangangahulugang naputol ang JSON. Napa-parse ito kapag isinara ang mga bracket pero tahimik na nawawala ang data, kaya ipadala ulit nang may mas malaking puwang.
-   Ayusin lang ang may iisang kahulugan: trailing comma, True/None na istilong Python at single quote. Tanggihan ang lahat ng iba at magtanong ulit.
-   Tinatanggap ng json module ng Python ang NaN at Infinity bilang default; hindi ito pinapayagan ng RFC 8259. Tanggihan ang mga ito, o papalya ang ibang parser sa susunod na bahagi.
-   Sa BroadNet Inference, GLM 5.3 at Qwen3.8 27B lang ang may dokumentadong structured output. Sa ibang model, gumamit ng JSON na nasa prompt lang kasama ang repair at validation na ito.

**Sa page na ito**

1.  Bakit invalid JSON ang ibinabalik ng mga LLM?
2.  Bakit hindi dapat i-repair ang naputol na JSON?
3.  Isang repair function na ligtas na kaso lang ang inaayos
4.  Paano dapat mag-retry kapag pumalya ang repair?
5.  Hindi na ba ito kailangan kung may structured output?
6.  Saan bagay ang BroadNet Inference

Tinatawag ng code mo ang `json.loads()` sa sagot ng model at nakakakuha ng `JSONDecodeError: Expecting value: line 1 column 1`. O kaya napa-parse ito, pero string ang isang field na dapat sana ay number. Inaayos ng post na ito ang mga sanhi ayon sa kung ano ang ligtas mong magagawa sa bawat isa, nagbibigay ng tested na Python function na nag-aayos lang ng malinaw na kaso, at nagpapakita ng retry loop na alam kung kailan walang maitutulong ang retry.

Nasa [JSON mode vs json\_schema](https://broadrouter.com/fil/blog/structured-output-json-schema/) ang pagpili sa pagitan ng [JSON mode](https://broadrouter.com/fil/glossary/json-mode/) at `json_schema`. Tungkol ang post na ito sa kung ano ang gagawin sa sagot na talagang natanggap mo.

## Bakit invalid JSON ang ibinabalik ng mga LLM?

Isa-isang token ang pagsulat ng model sa text. Maliban kung kinokontrol ng server ang decoding, walang pumipigil dito na magdagdag ng magiliw na pangungusap o maubusan ng puwang. Ang mga karaniwang palya:

| Ang nakikita mo | Sanhi | Ligtas bang ayusin sa code? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` sa paligid ng object | Nakasanayang chat formatting | Oo: alisin ang fence |
| “Here is the JSON:” bago, “Let me know…” pagkatapos | Parehong nakasanayan | Oo: basahin lang ang unang value |
| `<think>...</think>` bago ang object | Reasoning text sa content field sa ilang server | Oo: alisin ang block |
| Natatapos sa gitna ng string, bukas pa ang mga bracket | Tumama sa `max_tokens` | Hindi: ipadala ulit nang may mas malaking puwang |
| Walang laman na content | Naubos ng reasoning ang buong budget | Hindi: ipadala ulit nang may mas malaking puwang |
| `{"a": 1,}` | Trailing comma; pinapayagan ito ng JavaScript, hindi ng [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) | Oo: iisa ang kahulugan |
| `{'a': True, 'b': None}` | Syntax ng Python | Oo: ligtas itong nababasa ng `ast.literal_eval` |
| `NaN`, `Infinity` | Hindi JSON; tinatanggap ng Python bilang default | Hindi: tanggihan |
| Valid na JSON, maling type o kulang na field | Hindi ipinapatupad ang schema | Hindi: magtanong ulit kasama ang error |

Ang hangganan ay ang pagkalabo. Kung iisa lang talaga ang posibleng ibig sabihin ng model, ayusin ito sa code at i-log na ginawa mo. Kung kailangan mong manghula, tanggihan ang sagot.

## Bakit hindi dapat i-repair ang naputol na JSON?

Dahil mukhang tama ang naayos na bersyon pero hindi. Pinatakbo namin ang [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, isang sikat na library na may MIT license, sa sagot na naputol sa gitna ng salita:

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

Nagbalik ito ng valid na JSON na ang city ay “Jed”. Tapat dito ang README nito: “automatically completes missing values in JSON fields with reasonable defaults” (salin: awtomatikong pinupunan ang nawawalang value sa mga JSON field ng makatwirang default). Kapaki-pakinabang iyan sa pagbasa ng log. Pero para sa data na iniimbak mo o pinagbabatayan ng aksyon, ginagawa nitong tahimik na palya ang palyang dapat ay nakikita.

Tingnan ang `finish_reason` bago ka mag-parse. Ang `"length"` ay nangangahulugang tumama ang sagot sa [`max_tokens`](https://broadrouter.com/fil/glossary/max-tokens/). Papalya rin sa parehong paraan ang pagpapadala ulit ng parehong request na may parehong limit, kaya doblehin ang limit o humingi ng mas kaunti kada call. Mas madalas ito sa mga reasoning model: sabi ng [API reference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-fix-invalid-json-from-llm&utm_content=body) ng BroadNet, nagre-reason muna bago sumagot ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B, at kasama ang reasoning sa `max_tokens`. Kapag maliit ang limit, puwedeng bumalik na walang laman ang sagot. Mag-iwan ng 1,000 token o higit pa, o itakda ang `reasoning_effort` sa `low`; nasa [post tungkol sa reasoning budget](https://broadrouter.com/fil/blog/reasoning-model-max-tokens-budget/) ang mga numero.

## Isang repair function na ligtas na kaso lang ang inaayos

Standard library lang ang gamit nito. Ibinabalik nito ang na-parse na value at listahan ng mga repair na ginawa nito, para mabilang mo ang mga ito.

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

Paano gumagana ang bawat hakbang:

1.  **Ang naputol at walang lamang sagot** ay nagra-raise bago pa ang anumang parsing, kaya hindi sila nagiging data.
2.  **Ang mga fence at reasoning block** ay inaalis gamit ang dalawang regular expression.
3.  **Ang `raw_decode`** ang pangunahing tool. Sabi ng docs ng Python, nagde-decode ito ng document “from a string that may have extraneous data at the end” (salin: mula sa string na maaaring may sobrang data sa dulo), at ibinabalik kung saan ito huminto. Nagsisimula sa unang `{` o `[`, nilalaktawan nito ang prose bago ang object at hindi pinapansin ang prose pagkatapos. Kung pumalya ang pag-decode sa isang brace sa prose, susubukan nito ang susunod.
4.  **Ang bracket scan** ay dumadaan sa text habang sinusubaybayan ang mga string at escape. Kapag may bukas pang bracket, naputol ang sagot kahit hindi iyon sinabi ng `finish_reason`; nagra-raise iyon. Inaalis ang mga comma na direktang bago ang `}` o `]` sa labas ng string.
5.  **Binabasa ng `ast.literal_eval`** ang output na istilong Python na may single quote, `True` at `None`. Mga literal lang ang ine-evaluate nito at hindi ito kailanman nagpapatakbo ng code. Kailangan pagkatapos na ma-serialise ang resulta bilang mahigpit na JSON.
6.  **Ang `NaN` at `Infinity`** ay nagra-raise, sa pamamagitan ng `parse_constant`. Tinatanggap ang mga ito ng `json` ng Python bilang default; sabi ng RFC 8259, “are not permitted” (salin: hindi pinapayagan) ang mga ito, at tinatanggihan ang mga ito ng `JSON.parse` ng JavaScript.

Pinatakbo namin ito sa 17 test string: malinis na JSON, JSON na may fence, Arabic na key at value sa loob ng fence, prose bago at pagkatapos, `{name}` na placeholder sa prose bago ang object, `<think>` block, trailing comma sa object at array, comma at bracket sa loob ng string, escaped quote, Windows path na nagtatapos sa backslash, Python literal, `NaN`, walang lamang sagot, sagot na naputol nang may at walang `finish_reason: "length"`, at dalawang magkasunod na object. Lahat ay kumilos ayon sa sinasabi ng table sa itaas. May isang test na nakahuli ng totoong bug: sa isang naunang bersyon, binabaligtad ang escape flag bago i-check ang closing quote, kaya nawala ang comma ng `"he said \"hi,]\""`. I-test ang sarili mong repair code sa mga escaped quote.

Dalawang limit na dapat mong malaman. Kapag dalawang magkasunod na object, ang una ang ibinabalik nito; kung gusto mo ng maraming item, humingi ng iisang JSON array. At ang single-quoted na output ng Python na may double quote sa loob ng string ay puwedeng mabasa nang mali ng bracket scan at matanggihan. Ang pagtanggi ang ligtas na uri ng palya.

## Paano dapat mag-retry kapag pumalya ang repair?

Format ang hinahawakan ng repair. Content naman ang sa validation: tamang field, tamang type, makatwirang value. Nagva-validate ang loop na ito gamit ang `jsonschema` package at pinipili ang retry ayon sa sanhi:

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

Ang mga patakaran sa loop na iyan:

-   **Naputol: ipadala ulit ang parehong mga message na doble ang limit.** Kapag nagdagdag ng “please fix” na message, hahaba ang prompt at hindi iikli ang output.
-   **Hindi JSON, o maling hugis: ibalik ang eksaktong error.** Ang “amount: ‘1200’ is not of type ‘number’” ay nagbibigay sa model ng tiyak na aayusin. Madalas inuulit ng basta-bastang retry ang parehong mali.
-   **Hanggang tatlong attempt lang.** Ipinapadala ulit ng bawat retry ang buong usapan bilang [input token](https://broadrouter.com/fil/glossary/input-and-output-tokens/). Pagkatapos ng tatlo, i-log ang input at ipasa ito sa ibang paraan.
-   **I-log ang listahan ng repair.** Kapag dumarami ang “removed code fence” pagkatapos magpalit ng prompt, ibig sabihin lumala ang prompt, kahit walang pumalya.

Pinatakbo namin ang loop na ito laban sa isang lokal na mock server na nagpe-play back ng mga scripted na sagot. Ang sagot na may fence, trailing comma at `"amount": "1200"` bilang string ay na-repair, pumalya sa validation, at naayos sa ikalawang call matapos ibalik ang error. Ang sagot na naputol na may `finish_reason: "length"` ay ipinadala ulit na tinaasan ang `max_tokens` mula 1,500 papuntang 3,000 at nagtagumpay. Ini-record ng mock ang request sa bawat pagkakataon, na nagkumpirma ng bilang ng message at limit na ipinadala ng loop. Puwedeng iba ang paraan ng pagpalya ng totoong model, kaya patakbuhin ito sa 100 sarili mong input bago pagkatiwalaan ang mga numero.

## Hindi na ba ito kailangan kung may structured output?

Inaalis nito ang karamihan. Ang server na kinokontrol ang decoding ayon sa schema mo ay hindi makakapaglabas ng fence, trailing comma o kulang na field. Ginagawa ito ng vLLM, isang karaniwang server para sa open model, gamit ang xgrammar o guidance backend. Dalawang palya pa rin ang natitira: truncation sa `max_tokens`, at refusal. Sabi ng OpenAI, valid ang output ng JSON mode “except for in some edge cases” (salin: maliban sa ilang edge case) at “must detect and handle” (salin: kailangang tuklasin at hawakan) ng application mo ang output na hindi kumpletong object. Kaya panatilihin ang check sa `finish_reason` at ang validator, kahit may `json_schema`.

Ang napipigilan ng bawat paraan:

| Paraan | Fence at prose | Syntax error | Maling hugis | Truncation |
| --- | --- | --- | --- | --- |
| Prompt lang (“reply with JSON”) | Nababawasan | Nababawasan | Nababawasan | Hindi |
| JSON mode (`json_object`) | Oo | Oo | Hindi | Hindi |
| Structured output (`json_schema`, ipinapatupad) | Oo | Oo | Oo | Hindi |

Sa JSON mode, sinasabi rin ng OpenAI na “must always instruct the model to produce JSON” (salin: kailangang laging utusan ang model na gumawa ng JSON) ka sa isang message; kung hindi, puwede itong maglabas ng whitespace hanggang tumama sa token limit. Iba-iba ang ibang OpenAI-compatible na server, kaya i-test ang mode sa model na ilalabas mo. Nasa [post tungkol sa structured output](https://broadrouter.com/fil/blog/structured-output-json-schema/) ang test.

Para i-check nang mano-mano ang isang sagot, i-paste ito sa [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/), o gumawa ng mahigpit na schema mula sa isang sample object gamit ang [JSON schema generator](https://broadrouter.com/tools/json-schema-generator/).

## Saan bagay ang BroadNet Inference

Ang BroadRouter ay website ng BroadNet. Sa API reference ng BroadNet, nakalista ang structured output para sa [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) at [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/) lang, at hindi nito pinangangalanan ang request parameter, kaya i-test ang `json_schema` sa model bago umasa rito. Sa [DeepSeek V4.1 Flash](https://broadrouter.com/fil/models/deepseek-v4.1-flash/) at [Gemma 4 VL 26B](https://broadrouter.com/fil/models/gemma-4-vl-26b/), gumamit ng JSON na nasa prompt lang kasama ang repair function at validator sa itaas. Nagre-reason muna bago sumagot ang tatlo sa apat na model, kaya mag-budget ng `max_tokens` para dito. Para sa maramihang extraction, ipinapakita ng [post tungkol sa batch runner](https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/) kung paano i-log ang `finish_reason` kada item. Hindi itinatago ang mga prompt at sagot pagkatapos ng bawat request.

Mga libreng tool para rito (Ingles)

-   [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.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[JSON mode](https://broadrouter.com/fil/glossary/json-mode/)

Ang JSON mode ay isang setting ng LLM API, response\_format {"type": "json\_object"} sa mga OpenAI-style na API, na ginagawang valid at nae-parse na JSON ang sagot ng model. Hindi tulad ng structured outputs na may JSON Schema, hindi nito ginagarantiya kung anong mga key, type o value ang laman ng object.

[Structured output](https://broadrouter.com/fil/glossary/structured-output/)

Ang structured output ay feature ng LLM API na naglilimita sa sagot ng model sa format na itinakda ng developer, kadalasang JSON Schema, para maaasahang ma-parse ito ng code. Mas mahigpit ito kaysa sa JSON mode, na gumagarantiya ng valid na JSON pero hindi ng partikular na hugis.

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[JSON Schema](https://broadrouter.com/fil/glossary/json-schema/)

Ang JSON Schema ay isang vocabulary, nakasulat sa JSON, para ilarawan at i-validate ang istruktura ng JSON data: mga type, required na field, pinapayagang value at nesting. 2020-12 ang kasalukuyang bersyon. Ginagamit ito ng mga LLM API para tukuyin ang tool parameters at ang eksaktong hugis na dapat sundin ng structured output.

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Context window](https://broadrouter.com/fil/glossary/context-window/)

Ang context window ay ang pinakamaraming token na kayang hawakan ng isang language model sa iisang request. Sakop nito ang prompt, history ng usapan, tool definitions, mga larawan at ang nabuong output, kasama ang anumang reasoning tokens. Ang hindi kasya ay kailangang bawasan, ibuod o hatiin sa ilang request.

[Input at output token (input and output tokens)](https://broadrouter.com/fil/glossary/input-and-output-tokens/)

Ang input token ay ang mga token na binabasa ng language model sa isang request, kasama ang system prompt, history ng usapan, tool definitions at mga larawan. Ang output token ay ang mga token na binubuo nito bilang sagot, kasama ang anumang reasoning. Kadalasang magkahiwalay ang presyo ng dalawa, at mas mahal ang output.

## Mga tanong

### Bakit nasa loob ng markdown code block ang JSON na ibinabalik ng LLM ko?

Karaniwang pino-format ng mga chat model ang code para sa tao, at code fence ang paraan ng mga chat interface sa pagpapakita nito. Humingi ng "JSON lang, walang code fence", pero alisin pa rin ang mga fence sa code: binababa ng utos ang dalas, hindi nito inaalis.

### Paano ko aayusin ang JSONDecodeError sa output ng LLM?

Tingnan muna ang finish\_reason. Kung "length", naputol ang sagot: taasan ang max\_tokens at ipadala ulit. Kung hindi, alisin ang code fence at i-decode ang unang JSON value gamit ang raw\_decode, na hindi pinapansin ang text pagkatapos nito. Ayusin ang trailing comma, saka i-validate. Kung pumapalya pa rin, magtanong ulit kasama ang error.

### Dapat ba akong gumamit ng JSON repair library?

Para sa log at debugging, oo. Para sa data na pagbabatayan mo ng aksyon, mag-ingat. Pinupunan ng default ng mga library gaya ng json\_repair ang nawawalang value, kaya bumabalik ang naputol na city na "Jed" bilang valid na "Jed". Tanggihan ang naputol na output at ipadala ulit.

### Bakit naputol ang JSON output ng LLM ko?

Tumama ang sagot sa max\_tokens. Sa mga reasoning model gaya ng DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B, kasama ang reasoning sa limit na iyon, kaya puwedeng masyadong kaunti ang matirang puwang pagkatapos ng mahabang pag-iisip. Taasan ang limit, itakda ang reasoning\_effort sa low, o humingi ng mas kaunting output kada call.

### Garantisado ba ng JSON mode ang valid na JSON?

Halos. Sabi ng OpenAI, valid na JSON ang output ng JSON mode "except for in some edge cases" (salin: maliban sa ilang edge case), gaya ng pag-abot sa token limit, at hindi nito ipinapatupad ang schema mo. Nagdadagdag ng schema adherence ang structured output na may json\_schema kung ipinapatupad ito ng provider. I-validate pa rin alinman dito.

### Aling mga model ng BroadNet ang sumusuporta sa structured output?

Nakalista sa API reference ng BroadNet ang structured output para sa GLM 5.3 at Qwen3.8 27B, sinuri noong Nobyembre 15, 2026. Hindi ito nakalista para sa DeepSeek V4.1 Flash o Gemma 4 VL 26B, kaya JSON na nasa prompt lang kasama ang repair at validation ang gamitin sa mga iyon.

## Magbasa pa

-   [JSON mode vs json\_schema: structured output na maaasahan](https://broadrouter.com/fil/blog/structured-output-json-schema/)
-   [Tool calling sa open model: schema, parallel call, retry](https://broadrouter.com/fil/blog/tool-calling-open-models/)
-   [Paano itakda ang max\_tokens sa reasoning model: paraan ng pag-budget](https://broadrouter.com/fil/blog/reasoning-model-max-tokens-budget/)
-   [Arabic text classification gamit ang LLM: sentiment, intent, triage](https://broadrouter.com/fil/blog/arabic-text-classification-llm/)
-   [LLM batch processing nang walang Batch API: resumable na runner](https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/)
-   [Arabic translation ng app strings gamit ang LLM: placeholder, plural](https://broadrouter.com/fil/blog/translate-app-strings-to-arabic-llm/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Basahin ang mga Arabic na invoice at resibo gamit ang vision model](https://broadrouter.com/fil/guides/read-arabic-invoices-with-vision/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-fix-invalid-json-from-llm&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference: GLM 5.3 at Qwen3.8 27B lang ang may nakalistang tools at structured output; nagre-reason ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B, at kasama ang reasoning sa max\_tokens (sinuri noong 2026-11-16) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [Structured Outputs guide ng OpenAI: JSON mode vs schema adherence, utusan ang model na gumawa ng JSON, whitespace hanggang token limit, hindi kumpletong output, refusal (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format: grammar ng object, double-quoted na string, hindi pinapayagan ang Infinity at NaN (sinuri noong 2026-11-15)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Dokumentasyon ng Python, json module: JSONDecoder.raw\_decode, tinatanggap ang NaN at Infinity bilang default, parse\_constant (sinuri noong 2026-11-15)](https://docs.python.org/3/library/json.html)
-   [json\_repair sa GitHub (MIT): inaayos ang sirang JSON at pinupunan ng default ang nawawalang value (tested ang bersyon 0.64.9; sinuri noong 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [Dokumentasyon ng vLLM, structured outputs: json\_schema, regex, choice at grammar gamit ang xgrammar o guidance backend (sinuri noong 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
