JSON Toolkit

JSON от LLM обрезался: сначала посмотрите причину остановки, потом говорите о починке

Главное: Модель вернула JSON, оборвавшийся на середине значения, а парсер сообщает только номер столбца. Закрыть скобки — и разбор снова проходит, но каждый недостающий кусок теперь спрятан внутри данных. Статья проводит границу между тем, что починка обрезки может честно вернуть, и тем, что надо запрашивать заново: проверка stop_reason, расчёт лимита, порядок полей схемы.

Практика~5 мин чтенияОпубликовано 2026-11-14Обновлено 2026-11-14
Закрытие обрезанного JSON через стек после разбора с учётом строк

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

Как выглядит обрезка: одного номера столбца мало

Модель пишет JSON по вашей схеме, упирается в лимит вывода, и текст просто заканчивается. Скопируйте это в модуль json на Python 3.11:

{"scores": {"clarity": 8, "depth": 7}, "items": [{"name": "a", "qty": 2}, {"name": "b", "qty"

json.loads выдаёт Expecting ':' delimiter, col 94. Столбец указывает на ключ "qty" без значения, но настоящая причина — у документа нет конца. Жадная регулярка, дописывающая "} в конце, разбор не спасает; закрытие стеком с учётом строк (шестой раздел) разбирается, но в items остаются 2 записи, а третья частичная исчезает. Номер столбца говорит, где текст остановился. Он никогда не говорит, сколько вы потеряли.

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

Обрезка — не порча синтаксиса: слепое пятно починщиков

Починщики вроде jsonrepair превращают синтаксически сломанный JSON в легальный: снимают маркдаун-обёртки, убирают запятые, меняют кавычки. Там замысел цел, а починка — лишь уборка. Обрезанный ввод для того же инструмента выглядит как сломанный JSON, поэтому он закрывает открытую строку, массив и объект и возвращает что-то разбираемое. Из 83 обрезанных отчётов Claude инструмент «починил» 79, жёстко отказали лишь 4. Мониторинг ошибок видел частоту в двадцать раз ниже реальной.

Как выглядел результат? Отзыв к вопросу 6 обрывался на середине фразы, вопросов 7–9 не было, массив next_steps исчез. Pydantic всё равно валидировал, потому что у next_steps было значение по умолчанию [], а у списка не было ограничения длины. Все слои делали свою работу. Продукт выдал уверенный и неверный отчёт.

Поставьте починку синтаксиса на путь обрезки — и она тихо превратится из уборки в выдумывание. Поэтому сначала граница: инструмент починки работает только с грязью формата на полных ответах; обрезанный ответ не должен до него доходить вообще. Про грязь формата читайте в руководстве по починке JSON.

Первый шаг всегда — причина остановки

Все крупные API бесплатно сообщают в метаданных, почему генерация прекратилась. Это же самая игнорируемая строка кода в интеграциях с LLM. Anthropic отдаёт stop_reason, чат-API OpenAI — finish_reason: max_tokens означает обрезку, end_turn или stop — что модель закончила сама.

resp = client.messages.create(model=MODEL, max_tokens=4096, ...)
if resp.stop_reason != "end_turn":
    raise TruncatedOutput(
        f"stop_reason={resp.stop_reason}, "
        f"output_tokens={resp.usage.output_tokens}"
    )
data = json.loads(resp.content[0].text)

Когда обрезка стала явным исключением, у повтора появляется условие срабатывания, а у мониторинга — источник тревоги. Те 83 отчёта нашлись задним числом одним запросом по полю stop_reason в логах, которые хранились всегда и никогда не читались. Gemini сигнализирует length и incomplete в том же смысле; подключая нового провайдера, сверяйтесь с таблицей соответствия, а не угадывайте.

max_tokens — это ограда, а не бюджет

Прямая причина обычно — лимит, рассчитанный на прежнюю версию продукта: 1500 токенов, которые с приходом длинных сессий режут 39% длинных отчётов. Поднять лимит бесплатно. Оплата идёт по фактически сгенерированным токенам, поэтому 4096 на отчёт в 1100 токенов стоит ровно столько же, сколько 1500. Лимит нужен, чтобы остановить улёт генерации, а не чтобы экономить.

Считайте по данным: неделю наблюдайте реальное распределение, возьмите p99 и оставьте запас. Команда из того инцидента выбрала 4096, потому что после исправления p99 был 2350. Второе направление — уменьшить сам вывод. Повторяющиеся ключи в однородных массивах съедают основную часть токенов; табличная кодировка перед вызовом (см. руководство по формату TOON) сокращает объём, который должен уместиться в лимит.

Порядок полей схемы определяет, что обрежется

Модели пишут JSON сверху вниз. Когда бюджет кончается, первым исчезает то, что стоит в конце списка свойств. Схема в порядке summary, per_question_feedback, scores, next_steps теряет сначала scores — именно то, что пользователь снимает скриншотом и сравнивает каждую неделю. Исправление — перестановка: короткие критичные поля вперёд, длинные и воспроизводимые детали потом, свободный текст в самом конце.

Поведение провайдеров тоже меняет последствия одной и той же обрезки:

Провайдер Механизм структурированного вывода Поведение при обрезке
OpenAI response_format с strict: true Гарантия на уровне сэмплирования, но самый узкий диалект; обычно отказывается генерировать
Anthropic input_schema в tool use Гарантии на этапе декодирования нет; может вернуть незакрытые скобки
Gemini responseSchema с MIME JSON На декодировании принудительно только enum и тип; обрезка по-прежнему возможна

«Структурированный вывод включён, валидация не нужна» — заблуждение. Чем слабее гарантия провайдера, тем нужнее своя проверка схемы и цикл повторов. Как собрать такой контрактный тест, есть в контрактных тестах JSON Schema.

Когда частичное восстановление действительно нужно: закрытие стеком с учётом строк

Бывают случаи, когда из фрагмента надо выжать хоть что-то: стриминговый предпросмотр, деградировавший ответ, очередь на ручную проверку. Тогда закрытие — последняя ступень лестницы починки, и у неё два условия. Первое: обход скобок должен учитывать строки, следя за кавычками и экранированием посимвольно, иначе { внутри значения ломает стек. Второе: неполные пары «ключ-значение» надо удалить до закрытия. Ключ "qty" без значения нельзя закрыть в {"qty"}; пара уходит целиком.

def close_truncated(s: str) -> str:
    # 1) Обход с учётом строк; сначала закрыть открытую строку
    out, in_str, esc = [], False, False
    for ch in s:
        out.append(ch)
        if esc: esc = False; continue
        if ch == '\\' and in_str: esc = True; continue
        if ch == '"': in_str = not in_str
    text = ''.join(out) + ('"' if in_str else '')
    # 2) Удалить неполные пары и висящие двоеточие/запятую
    text = re.sub(r',\s*"[^"]*"\s*$', '', text)
    text = re.sub(r'[{,]\s*"[^"]*"\s*:\s*$', '}', text)
    text = re.sub(r':\s*$', '', text)
    text = re.sub(r',\s*$', '', text)
    # 3) Пересканировать стек и закрыть по LIFO
    stack, in_str, esc = [], False, False
    for ch in text:
        if esc: esc = False; continue
        if ch == '\\' and in_str: esc = True; continue
        if ch == '"': in_str = not in_str; continue
        if not in_str:
            if ch in '{[': stack.append(ch)
            elif ch in '}]' and stack: stack.pop()
    return text + ''.join('}' if c == '{' else ']' for c in reversed(stack))

На вводе из начала статьи это возвращает {"scores": {...}, "items": [{"name": "a", "qty": 2}, {"name": "b"}]} на Python 3.11 со стандартной библиотекой. Разбор проходит, третья запись теряется. На стороне локальных моделей тем же занимаются специализированные библиотеки вроде partial-json-parser: закрыть стеком, отрезать по полноте.

Главное — раскрытие. Функция закрытия обязана сообщать, на какой ступени получен результат; всё, что вышло со ступени truncation, — частичный результат, и это надо помечать: запросить недостающий фрагмент, повторить с большим лимитом или сказать пользователю, что данные неполны. Делать вид, что ничего не случилось, — это выдумывание галлюцинаций детерминированным кодом.

Починить или повторить: таблица границ

Форма ввода Правильное действие Почему
Обёртки, лишние запятые, одинарные кавычки Инструмент починки Замысел цел, грязна только синтаксис
Обрыв посреди строки Повтор или частичное восстановление с раскрытием Самого значения не хватает
Обрыв посреди структуры Частичное восстановление с раскрытием Завершённые поля выживают, частичные пары уходят
Разбирается, но выглядит неверно Проверка бизнес-логикой Это не обрезка, но часто идёт вместе с ней

Одна финансовая команда измерила цену. Длинные счета обрезались, закрытие скобок давало валидный JSON, отсутствующее поле total получало значение по умолчанию 0, и система с 98,2% соответствия формату выдавала около 200 неверных счетов в месяц. После того как обрезку стали считать жёсткой деградацией и добавили проверку тождества (total == сумма позиций), доля денежных ошибок упала с 0,8% до 0,02%, а соответствие формату выросло лишь до 99,1%. Три месяца оптимизации «соответствия формату» били по неверной метрике. Пройти парсер — не то же самое, что пройти бизнес.

Чек-лист из четырёх пунктов: проверяйте причину остановки до разбора; задавайте лимит по p99, а не как бюджет; ставьте критичные поля схемы вперёд; давайте починщику только грязь формата полных ответов. Выполните все четыре — и обрезка вернётся из тихой порчи данных в громкий и повторяемый сбой.

Можно просто закрыть скобки и использовать результат

Нет. Закрытие гарантирует лишь синтаксическую легальность, данные остаются фрагментом: фраза обрывается, последние записи потеряны, вместо реальных значений стоят значения по умолчанию. Помечайте вывод как частичный, запускайте повтор или деградацию и логируйте долю восстановления.

Как отличить обрезку от настоящей синтаксической ошибки

Смотрите причину остановки в метаданных: max_tokens, length или incomplete — обрезка; end_turn или stop при сбое разбора — реальная порча синтаксиса. Без метаданных смотрите на конец: обрыв внутри кавычек или скобок с незакрытой внешней структурой почти всегда обрезка.

Почему починенная обрезка опаснее громкого сбоя

Починщик оптимизирует «чтобы разбиралось», а закрытая обрезка разбирается, поэтому мониторинг молчит, а последующая валидация проходит благодаря значениям по умолчанию. Так 83 обрезанных отчёта дали лишь 4 ошибки. У инструмента нет понятия замысла, он не знает, чего не хватает, поэтому обрезку надо перехватывать выше по потоку.

Увеличение max_tokens стоит дороже

Нет. Оплата идёт по фактически сгенерированным токенам, лимит — только ограда. 4096 при 1100 сгенерированных токенах стоит ровно как 1500. Ставьте по реальному p99 с запасом и вкладывайтесь в предотвращение улёта генерации.

Источники

Подходящие инструменты

Похожие статьи

Руководство по восстановлению JSON: как спасти сломанный вывод LLM и сохранить доверие

Вывод LLM, завёрнутый в markdown-ограждение, с завершающими запятыми и литералами Python, строгий парсер отвергает целиком — как и конфиги, отредактированные вручную без кавычек. Это руководство проводит настоящую границу между девятью классами ошибок, которые восстановитель исправляет, и четырьмя, которые не исправит никогда, объясняет, почему автомат состояний побеждает регулярные выражения, и даёт цепочку разбора, готовую к продакшену, с jsonrepair и json-repair.

Средний~6 мин чтенияОбновлено 2026-11-08

Руководство по формату TOON: облегчите JSON перед передачей в LLM

Когда вы передаёте однородный массив языковой модели в формате JSON, повторяющиеся имена ключей и скобки съедают токены. TOON объявляет структуру один раз через индентированные объекты и табличные массивы, а данные выгружает строку за строкой. Официальные бенчмарки показывают около 40% экономии токенов при более высокой точности парсинга. Это руководство охватывает синтаксис, когда экономия работает, когда конвертировать не стоит и как соединить encode и decode.

Средний~6 мин чтенияОбновлено 2026-11-10

Тестирование JSON Schema как контракта: встроите правила валидации в CI

Схема не заканчивается написанием — именно с неё начинается деградация. Одна опечатка тихо ослабляет валидацию, один рефакторинг ломает все фикстуры. Здесь разобран рабочий набор контрактного тестирования: позитивные, негативные и снапшот-фикстуры, линт самой схемы, однократная компиляция с повторным использованием и четыре ворот CI, превращающих поломку контракта в красную сборку.

Средний~8 мин чтенияОбновлено 2026-11-05