BroadRouter

Как исправить невалидный JSON от LLM: причины, починка, повтор

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

Сначала проверьте finish_reason: ответ, обрезанный по max_tokens, безопасно не починить, поэтому увеличьте лимит и отправьте запрос заново. В остальных случаях уберите обёртку блока кода и текст вокруг, декодируйте первое JSON-значение и исправьте только однозначные ошибки вроде висячих запятых. Валидируйте по схеме, а при ошибке один-два раза отправьте её точный текст обратно. Структурированный вывод там, где он поддерживается, предотвращает большую часть этого.

Ваш код вызывает json.loads() на ответе модели и получает JSONDecodeError: Expecting value: line 1 column 1. Или разбор проходит, но поле оказывается строкой там, где вы ждали число. В этой статье причины разложены по тому, что с каждой можно безопасно сделать; есть проверенная функция на Python, которая чинит только однозначные случаи, и цикл повторов, который знает, когда повтор не поможет.

Выбор между JSON mode и json_schema разобран в статье JSON mode или json_schema. Здесь речь о том, что делать с ответом, который вы фактически получили.

Почему LLM возвращают невалидный JSON?

Модель пишет текст по одному токену. Если сервер не ограничивает декодирование, ничто не мешает ей добавить дружелюбную фразу или упереться в лимит. Типичные сбои:

Что вы видите Причина Можно безопасно починить в коде?
```json … ``` вокруг объекта Привычка к чат-оформлению Да: убрать обёртку
«Here is the JSON:» до, «Let me know…» после Та же привычка Да: читать только первое значение
<think>...</think> перед объектом На некоторых серверах текст рассуждений попадает в поле content Да: удалить блок
Обрывается посреди строки, скобки не закрыты Упёрся в max_tokens Нет: отправить заново с бо́льшим лимитом
Пустой content Рассуждения израсходовали весь бюджет Нет: отправить заново с бо́льшим лимитом
{"a": 1,} Висячая запятая; JavaScript её допускает, RFC 8259 — нет Да: смысл однозначен
{'a': True, 'b': None} Синтаксис Python Да: ast.literal_eval читает его безопасно
NaN, Infinity Это не JSON; Python по умолчанию их принимает Нет: отклонить
Валидный JSON, но не те типы или нет полей Схема не обеспечивается Нет: запросить заново с ошибкой

Граница проходит по неоднозначности. Если модель могла иметь в виду ровно одно, исправьте это в коде и залогируйте, что исправили. Если пришлось бы угадывать, отклоните ответ.

Почему не стоит чинить обрезанный JSON?

Потому что починенная версия выглядит правильной, но такой не является. Мы прогнали json_repair 0.64.9, популярную библиотеку под лицензией MIT, на ответе, обрезанном посреди слова:

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

Она вернула валидный JSON с городом “Jed”. README библиотеки этого не скрывает: она “automatically completes missing values in JSON fields with reasonable defaults” (перевод: «автоматически дополняет недостающие значения в полях JSON разумными значениями по умолчанию»). Для чтения логов это полезно. Для данных, которые вы сохраняете или на основе которых действуете, это превращает видимый сбой в незаметный.

Проверяйте finish_reason до разбора. "length" означает, что ответ упёрся в max_tokens. Тот же запрос с тем же лимитом сломается так же, поэтому удвойте лимит или просите меньше за один вызов. Модели с рассуждениями делают это чаще: справочник API BroadNet говорит, что DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B рассуждают перед ответом, а рассуждения входят в max_tokens. При маленьком лимите ответ может прийти пустым. Оставляйте 1000 токенов и больше или ставьте reasoning_effort в low; цифры — в статье о бюджете на рассуждения.

Функция починки, которая исправляет только безопасные случаи

Здесь используется только стандартная библиотека. Функция возвращает разобранное значение и список сделанных исправлений, чтобы их можно было считать.

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

Как работает каждый шаг:

  1. Обрезанные и пустые ответы вызывают исключение ещё до разбора, поэтому никогда не становятся данными.
  2. Обёртки блоков кода и блоки рассуждений убираются двумя регулярными выражениями.
  3. raw_decode — ключевой инструмент. Документация Python говорит, что он декодирует документ “from a string that may have extraneous data at the end” (перевод: «из строки, в конце которой могут быть посторонние данные»), и возвращает позицию, где остановился. Начиная с первой { или [, он пропускает текст до объекта и игнорирует текст после. Если скобка в тексте не декодируется, пробуется следующая.
  4. Сканирование скобок проходит по тексту, отслеживая строки и экранирование. Незакрытые скобки означают, что ответ обрезан, даже если finish_reason об этом не сказал; в этом случае выбрасывается исключение. Запятые прямо перед } или ] вне строк удаляются.
  5. ast.literal_eval читает вывод в стиле Python с одинарными кавычками, True и None. Он вычисляет только литералы и никогда не выполняет код. Результат затем должен сериализоваться как строгий JSON.
  6. NaN и Infinity вызывают исключение через parse_constant. Модуль json в Python по умолчанию их принимает; RFC 8259 говорит, что они “are not permitted” (перевод: «не допускаются»), а JSON.parse в JavaScript их отклоняет.

Мы прогнали функцию на 17 тестовых строках: чистый JSON, JSON в блоке кода, арабские ключи и значения в блоке кода, текст до и после, плейсхолдер {name} в тексте перед объектом, блок <think>, висячие запятые в объектах и массивах, запятые и скобки внутри строк, экранированные кавычки, путь Windows с обратным слешем в конце, литералы Python, NaN, пустой ответ, ответ, обрезанный с finish_reason: "length" и без него, и два объекта подряд. Всё вело себя так, как описано в таблице выше. Один тест поймал настоящую ошибку: ранняя версия переключала флаг экранирования до проверки закрывающей кавычки, и строка "he said \"hi,]\"" теряла запятую. Тестируйте свой код починки на экранированных кавычках.

Два ограничения, о которых стоит знать. Если идут два объекта подряд, функция вернёт первый; если вам нужно несколько элементов, просите один JSON-массив. И вывод Python в одинарных кавычках, где внутри строки есть двойная кавычка, сканирование скобок может прочитать неверно и отклонить. Отклонение — безопасный вариант сбоя.

Как повторять запрос, если починка не удалась?

Починка отвечает за формат. Валидация отвечает за содержимое: нужные поля, нужные типы, разумные значения. Этот цикл валидирует через пакет jsonschema и выбирает вид повтора по причине:

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")

Правила этого цикла:

  • Обрезан — отправьте те же сообщения с удвоенным лимитом. Сообщение «пожалуйста, исправь» сделает промпт длиннее, а вывод не короче.
  • Не JSON или не та структура — отправьте точный текст ошибки. «amount: ‘1200’ is not of type ‘number’» даёт модели конкретное, что исправлять. Простой повтор часто воспроизводит ту же ошибку.
  • Не больше трёх попыток. Каждый повтор заново отправляет весь диалог как входные токены. После трёх попыток залогируйте входные данные и отправьте их по другому маршруту.
  • Логируйте список исправлений. Если после правки промпта растёт число «removed code fence», значит, промпт стал хуже, даже если ничего не упало.

Мы прогнали этот цикл на локальном mock-сервере, который воспроизводил заранее заданные ответы. Ответ в блоке кода с висячей запятой и "amount": "1200" в виде строки был починен, не прошёл валидацию и был исправлен со второго вызова после отправки ошибки. Ответ, обрезанный с finish_reason: "length", был отправлен заново с max_tokens, увеличенным с 1500 до 3000, и прошёл успешно. Mock-сервер каждый раз записывал запрос, что подтвердило число сообщений и лимит, отправленные циклом. Настоящая модель может сбоить иначе, поэтому прогоните цикл на 100 своих входных данных, прежде чем доверять цифрам.

Делает ли структурированный вывод всё это ненужным?

Он убирает бо́льшую часть. Сервер, который ограничивает декодирование вашей схемой, не может выдать обёртку блока кода, висячую запятую или пропущенное поле. vLLM, распространённый сервер для открытых моделей, делает это с бэкендами xgrammar или guidance. Но два сбоя остаются и тогда: обрезка по max_tokens и отказы. OpenAI отмечает, что вывод в JSON mode валиден “except for in some edge cases” (перевод: «за исключением некоторых пограничных случаев») и что ваше приложение “must detect and handle” (перевод: «должно обнаруживать и обрабатывать») вывод, который не является полным объектом. Поэтому оставьте проверку finish_reason и валидатор даже с json_schema.

Что предотвращает каждый подход:

Подход Обёртка и лишний текст Синтаксические ошибки Не та структура Обрезка
Только промпт («ответь в JSON») Реже Реже Реже Нет
JSON mode (json_object) Да Да Нет Нет
Структурированный вывод (json_schema, обеспечивается) Да Да Да Нет

Для JSON mode OpenAI также пишет, что вы “must always instruct the model to produce JSON” (перевод: «всегда должны указывать модели выдавать JSON») в одном из сообщений; иначе она может выдавать пробелы, пока не упрётся в лимит токенов. Другие OpenAI-совместимые серверы ведут себя по-разному, поэтому проверяйте режим на той модели, с которой выходите в продакшен. Тест — в статье о структурированном выводе.

Чтобы проверить ответ вручную, вставьте его в валидатор JSON-вывода LLM или постройте строгую схему по образцу объекта в генераторе JSON Schema.

Место BroadNet Inference

BroadRouter — сайт BroadNet. Справочник API BroadNet указывает структурированный вывод только для GLM 5.3 и Qwen3.8 27B и не называет параметр запроса, поэтому проверьте json_schema на модели, прежде чем на него полагаться. На DeepSeek V4.1 Flash и Gemma 4 VL 26B используйте JSON по инструкции в промпте с функцией починки и валидатором выше. Три из четырёх моделей рассуждают перед ответом, так что закладывайте на это max_tokens. Для массового извлечения данных в статье о пакетной обработке показано, как логировать finish_reason по каждому элементу. Промпты и ответы не хранятся после каждого запроса.

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

Почему LLM возвращает JSON внутри блока кода markdown?

Чат-модели обычно оформляют код для людей, а блок кода — это то, как его показывают чат-интерфейсы. Просите «только JSON, без блока кода», но всё равно убирайте обёртку в коде: инструкция снижает частоту, но не устраняет её.

Как исправить JSONDecodeError на ответе LLM?

Сначала посмотрите на finish_reason. Если там "length", ответ обрезан: увеличьте max_tokens и отправьте запрос заново. Если нет, уберите обёртку блока кода и декодируйте первое JSON-значение через raw_decode — он игнорирует текст после него. Исправьте висячие запятые и провалидируйте. Если не помогло, запросите ответ заново, приложив ошибку.

Стоит ли использовать библиотеку для починки JSON?

Для логов и отладки — да. Для данных, на основе которых вы что-то делаете, — осторожно. Библиотеки вроде json_repair достраивают недостающие значения значениями по умолчанию, так что обрезанный город "Jed" вернётся как валидный "Jed". Обрезанный вывод лучше отклонить и отправить запрос заново.

Почему JSON от LLM обрезается?

Ответ упёрся в max_tokens. У моделей с рассуждениями, таких как DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B, рассуждения входят в этот лимит, и долгое размышление может оставить слишком мало места. Увеличьте лимит, поставьте reasoning_effort low или просите меньше вывода за один вызов.

Гарантирует ли JSON mode валидный JSON?

Почти. OpenAI пишет, что вывод в JSON mode — валидный JSON "except for in some edge cases" (перевод: «за исключением некоторых пограничных случаев»), например при достижении лимита токенов, и вашу схему он не обеспечивает. Структурированный вывод с json_schema добавляет соответствие схеме там, где провайдер его обеспечивает. Валидируйте в любом случае.

Какие модели BroadNet поддерживают структурированный вывод?

Справочник API BroadNet указывает структурированный вывод для GLM 5.3 и Qwen3.8 27B (проверено 15 ноября 2026 года). Для DeepSeek V4.1 Flash и Gemma 4 VL 26B он не указан, поэтому на них используйте JSON по инструкции в промпте с починкой и валидацией.

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

Источники