Разработка программного обеспечения — это не только написание нового кода, но и постоянное взаимодействие с экосистемой зависимостей. Часто разработчики забывают, что их инструменты зависят от библиотек, которые сами по себе являются сложными системами с собственной историей, багами и патчами. Ярким примером такой ситуации стало недавнее обновление LLM (Large Language Models) версии 0.37.3, выпущенное Саймоном Уиллисоном. На первый взгляд, это может показаться рутинным исправлением ошибки, но за ним скрывается глубокая техническая проблема, связанная с обновлением движка базы данных SQLite до версии 3.54.1.
Этот инцидент наглядно демонстрирует, как даже мелкие изменения в поведении базовых SQL-функций могут привести к поломке логирования в более высокоуровневых приложениях. Для разработчиков, работающих с локальными LLM-клиентами, особенно в среде macOS через Homebrew, это обновление стало своего рода «тихой мину», которая взорвалась из-за несовместимости в обработке JSON-структур. В этой статье мы подробно разберем суть проблемы, технические детали бага в SQLite и, самое главное, практические решения, которые позволяют продолжить работу без потери данных.
01Контекст: LLM CLI и его зависимость от Homebrew
Инструмент LLM — это популярная утилита командной строки, которая позволяет разработчикам и исследователям взаимодействовать с большими языковыми моделями (LLM) прямо из терминала. Он широко используется для быстрого тестирования промптов, автоматизации задач и интеграции AI в рабочие процессы. Однако, как и многие современные инструменты, LLM не работает в вакууме. Он опирается на множество системных библиотек, одной из ключевых из которых является SQLite.
SQLite используется LLM для хранения истории запросов, конфигураций и, что особенно важно, для логирования действий. В экосистеме macOS основным менеджером пакетов является Homebrew. Именно Homebrew отвечает за установку и обновление программного обеспечения для пользователей. Недавнее обновление Homebrew принесло с собой самую свежую версию SQLite — 3.54.1. Это обновление должно было принести исправления безопасности и улучшения производительности, но оно также содержало изменение, которое оказалось критическим для совместимости с текущей версией LLM.
Проблема возникла не из-за ошибки в коде самого LLM, а из-за того, что поведение функции json_object в SQLite изменилось. Разработчики LLM полагались на определенное поведение, которое оказалось ошибочным с точки зрения спецификации SQL, но стабильным в предыдущих версиях. Когда Homebrew обновил SQLite, это «неофициальное» поведение перестало работать, что привело к сбоям в логировании.
02Суть бага: Что изменилось в SQLite 3.54.1?
Чтобы понять масштаб проблемы, нужно заглянуть в технические детали. В SQLite 3.54.0 существовала особенность (которая позже была признана багом) в обработке вложенных JSON-функций. Рассмотрим конкретный SQL-запрос, который активно использовался в коде LLM:
select json_object('a', (select json_array(1)))В версии SQLite 3.54.0 этот запрос возвращал результат:
{"a":[1]}Это выглядело логично: мы создаем объект JSON с ключом 'a', значением которого является массив [1]. Однако, когда пользователи обновили Homebrew и получили SQLite 3.54.1, тот же самый запрос начал возвращать совершенно другой результат:
{"a":"[1]"}Обратите внимание на разницу. В новом результате значение ключа 'a' стало строкой "[1]", а не массивом [1]. Это изменение сломало парсинг JSON в LLM, так как код ожидал получить массив, а получил строку. Последующие операции с этим данными приводили к ошибкам или некорректному логированию.

Создатель SQLite, D. Richard Hipp, объяснил, что поведение в версии 3.54.0 было ошибочным. Согласно официальной документации SQLite, функция (SELECT json_array(...)) возвращает SQL-текст, а не сам JSON-объект. Таким образом, когда вы вставляете результат подзапроса в json_object, SQLite воспринимает его как строку, которую нужно экранировать и превратить в JSON-строку. Поведение в 3.54.1 является правильным с точки зрения стандарта, а поведение в 3.54.0 — это баг, который был случайно исправлен.
03Почему это затронуло именно логирование?
Многие пользователи LLM задаются вопросом: почему такая, казалось бы, мелкая деталь с JSON-массивами ломает весь процесс логирования? Ответ кроется в том, как LLM сохраняет данные. При каждом взаимодействии с моделью LLM создает запись в базе данных SQLite. Эта запись содержит метаданные, сам промпт, ответ модели и дополнительную информацию, которая часто структурируется в виде JSON.
В частности, при логировании некоторых типов данных (например, списков токенов, параметров или вложенных структур конфигурации) LLM использует вложенные вызовы json_object и json_array. Если база данных возвращает строку вместо массива, парсер JSON в Python (или другом языке, на котором написан LLM) либо выбрасывает ошибку, либо сохраняет некорректные данные. В случае с LLM это приводило к тому, что логи становились нечитаемыми или полностью терялись.
Это классический пример проблемы «хрупкой зависимости». LLM полагался на конкретное поведение SQLite, которое не было задокументировано как стабильный API, а было побочным эффектом реализации. Когда SQLite исправил этот баг, LLM оказался неподготовленным. Выпуск версии 0.37.3 был необходим именно для того, чтобы адаптировать код LLM к новому, правильному поведению SQLite, а не для исправления ошибок в самой логике работы с LLM.
04Решение: Как обойти проблему с помощью функции json()
К счастью, решение проблемы уже найдено и задокументировано. Разработчикам не нужно откатывать SQLite или Homebrew. Вместо этого необходимо изменить SQL-запросы, которые генерирует LLM, чтобы явно преобразовать SQL-текст в JSON-объект. Это делается с помощью функции json().
Рабочий обходной путь (workaround) выглядит следующим образом:
select json_object('a', json((select json_array(1))))Давайте разберем, что здесь происходит. Функция json() принимает SQL-текст (в данном случае результат подзапроса (select json_array(1)), который возвращает строку "[1]") и преобразует его в настоящий JSON-объект. После этого json_object получает на вход уже валидный JSON-массив, а не строку, и корректно встраивает его в результирующий объект.
Результат выполнения этого запроса в SQLite 3.54.1 будет таким же, как и в 3.54.0:

{"a":[1]}Это гарантирует совместимость с новыми версиями SQLite и сохраняет правильную структуру данных. Для пользователей LLM это означает, что после обновления до версии 0.37.3, которая включает этот фикс, логирование должно работать корректно. Однако, если вы разрабатываете собственные расширения или скрипты, использующие LLM API, вам, возможно, придется применить этот патч самостоятельно.
json() в SQLite была добавлена для того, чтобы явно преобразовывать строки в JSON. Использование ее делает код более явным и устойчивым к изменениям в поведении других функций.05Последствия для сообщества разработчиков AI
Этот инцидент имеет более широкие последствия для сообщества разработчиков, работающих с AI. Он подчеркивает важность понимания того, как работают базовые компоненты, на которых строятся сложные системы. LLM — это не просто «черный ящик», это программное обеспечение, которое зависит от множества слоев абстракции.
Для разработчиков, работающих в России и других странах, где доступ к облачным API может быть ограничен, локальные решения, такие как LLM CLI, становятся еще более важными. Умение диагностировать и исправлять подобные проблемы на уровне зависимостей (как в случае с SQLite) является критически важным навыком. Это позволяет не только использовать инструменты, но и адаптировать их под свои нужды, обходить ограничения и обеспечивать стабильность работы.
Кроме того, этот случай напоминает о необходимости тщательного тестирования обновлений. Перед тем как обновлять Homebrew или другие менеджеры пакетов, стоит проверять, не затронуты ли ваши критически важные инструменты. В данном случае сообщество LLM быстро отреагировало и выпустило патч, но в других случаях задержка может быть дольше.
06Что это значит на практике
Для рядового пользователя LLM CLI эта ситуация означает следующее:
- Обновите LLM. Убедитесь, что вы используете версию 0.37.3 или новее. Это исправит проблему с логированием, вызванную обновлением SQLite.
- Не откатывайте SQLite. Не пытайтесь установить старую версию SQLite через Homebrew. Это может привести к другим проблемам безопасности и совместимости. Лучше исправить свой код (или код LLM), чтобы он работал с новой версией.
- Проверяйте логи. После обновления проверьте, корректно ли сохраняются ваши запросы. Если вы видите ошибки парсинга JSON, возможно, вам нужно будет вручную применить обходной путь с функцией
json()в своих собственных скриптах. - Будьте внимательны к зависимостям. Если вы разрабатываете свои инструменты на базе LLM, всегда проверяйте, как ваши SQL-запросы взаимодействуют с JSON-функциями. Используйте явное преобразование типов, чтобы избежать подобных проблем в будущем.
В конечном итоге, этот инцидент с SQLite 3.54.1 и LLM 0.37.3 — это не просто техническая деталь, а урок для всего сообщества. Он показывает, что даже самые надежные инструменты могут быть уязвимы к изменениям в базовых библиотеках. Но он также демонстрирует силу открытого сообщества: быстрое обнаружение проблемы, четкое объяснение причины и простое, эффективное решение. Это то, что делает разработку программного обеспечения такой увлекательной и сложной задачей одновременно.
Помните, что в мире AI и локальных моделей, где вы сами являетесь своим системным администратором, глубокое понимание того, как работают ваши инструменты, — это ваше главное преимущество. Изучайте документацию, следите за обновлениями и не бойтесь заглядывать в код. Именно так рождаются лучшие решения.
Источник: Simon Willison ↗
