feat: фоновый пинг апстримов в backoff-откате (probe_interval) — мгновенное возвращение в пул

Console Go (deepseek в thinking-режиме) в stateful-сессиях требует
reasoning_content на КАЖДОМ assistant-сообщении истории — живые 400
«The reasoning_content in the thinking mode must be passed back to the
API» (19:01, session 890fc602) шли именно на чистых ассистент-турах
без tool_calls, которые старый гейт пропускал. Снял гейт: поле
дописывается на каждом assistant-сообщении (текст из reasoning /
reasoning_details, пустая строка при reasoning_empty_ok) — как это
делает сам opencode («Deepseek requires all assistant messages to have
reasoning on them»). Тесты переписаны под новое поведение.

.gitea/workflows/build.yml

@@ -9,6 +9,10 @@ jobs:
     steps:
       - name: 'Checkout'
         uses: https://github.com/actions/checkout@v4
+      - name: 'Run tests'
+        uses: https://git.binom.pw/subochev/devops/build-gradle@main
+        with:
+          target: jvmTest
       - name: 'Build jar'
         uses: https://git.binom.pw/subochev/devops/build-gradle@main
         with:

CONFIG.md

@@ -41,9 +41,15 @@
 запросов сейчас идёт на каждый апстрим, и по этим счётчикам решаем, брать запрос
 или нет. Мы **не полагаемся** на `503`/`429` от самого апстрима, чтобы узнать,
 что он перегружен: такой ответ от провайдера — это уже сбой, а не способ
-управления нагрузкой. Если выбранный апстрим всё же вернул `5xx`/`429`, мы
+управления нагрузкой. Если выбранный апстрим всё же вернул `5xx`/`429`/`402`, мы
 освобождаем его слот и, при наличии, пробуем **следующий свободный** из списка
 модели (фейловер); если свободных не осталось — отдаём `503` от прокси.
+`402` (insufficient balance / исчерпан лимит токенов) — ошибка аккаунта
+провайдера, но фейловер имеет смысл: следующий апстрим может быть платёжеспособен.
+Повторяющиеся сбои уводятся из ротации экспоненциальным **backoff** (поле
+`backoff`, ниже): упавший апстрим «отдыхает» 1s, 2s, 4s, … до заданного потолка,
+и прокси его не трогает. Если **все** апстримы модели в откате — `503` с
+заголовком `Retry-After`.
 
 ## Формат файла
 
@@ -73,9 +79,14 @@ providers:
     url: "https://routerai.ru/api/v1"
     key: "sk-..."              # Bearer-ключ; можно подставлять из env
     max_concurrency: 4         # опционально; лимит по умолчанию для апстримов
+    session_header: x-opencode-session  # опционально; прокси считает сессию из истории
     patch:                     # уровень провайдера: ко всем его запросам
       provider:
         allow_fallbacks: false
+    backoff: P1M               # опционально; потолок экспоненциального backoff
+                                # на весь провайдер (ISO-8601: P1M, PT15M, P1D…)
+    probe_interval: PT1S       # опционально; фоновый пинг апстримов в откате
+                                # (как часто проверять, жив ли провайдер)
 
   - id: local-llama
     url: "http://10.0.0.5:8080/v1"
@@ -92,6 +103,10 @@ upstreams:
     patch:                     # уровень апстрима
       provider:
         ignore: [deepseek]
+    backoff: PT15M             # опционально; собственный backoff этой модели
+                                # (приоритет над backoff провайдера)
+    probe_interval: PT0S       # опционально; пинг отключён у этой модели
+                                # (приоритет над probe_interval провайдера)
 
   - id: local-qwen
     provider: local-llama
@@ -131,6 +146,335 @@ models:
 `patch` опционален на **любом** уровне (`providers` / `upstreams` / `models`):
 если ни одного нет — запрос проксируется как есть (исходное тело клиента).
 
+### Сессия по истории (`session_header`)
+
+`providers[].session_header` (опционально) — имя HTTP-заголовка, который прокси
+**вычисляет сам** из истории сообщений и ставит в запрос к этому провайдеру.
+Нужно для API, требующих стабильный идентификатор сессии (например,
+`x-opencode-session`), когда клиент его не шлёт или шлёт не то.
+
+```yaml
+providers:
+  - id: some-provider
+    url: "https://.../v1"
+    session_header: x-opencode-session
+```
+
+Как считается id:
+
+1. Берётся финальное тело запроса (после всех `patch`), из него — `messages`.
+2. Цепочка **инкрементальных SHA-256 префикс-хэшей** начинается с первого
+   `user`-сообщения (ведущий `system`-промпт игнорируется: он обычно одинаков
+   у всех сессий клиента и как признак сессии бесполезен).
+3. В реестре сессий ищется **наибольший общий префикс** (LCP) с уже виденной
+   историей. Нашли — используется id той сессии; не нашли — создаётся новая
+   (`id` = хэш всей истории на первом ходу).
+4. Заголовок ставится **всегда** (клиентское значение перезаписывается).
+
+Итог: пока история одной сессии растёт (дописываются assistant/user-сообщения),
+id не меняется; разные диалоги получают разные id.
+
+> **Ограничения.** Реестр живёт в памяти (LRU: 1000 сессий / 6 часов) — при
+> рестарте прокси активные сессии получат новый id. Обрезка/суммаризация
+> истории рвёт общий префикс → сессия распадётся на новую. Диалоги с
+> одинаковым первым `user`-сообщением неразличимы (склеятся).
+
+### Обработка think-тегов (`think_tags`)
+
+Некоторые провайдеры (например, **minimax**) отдают рассуждения модели не в
+отдельном поле `reasoning_content`, а прямо в `content`, обернув их тегами
+`<think>…</think>`. Флажок `think_tags` (опционально) разрешает прокси разрезать
+такой ответ и разложить его по полям.
+
+Поле доступно на двух уровнях:
+
+- `providers[].think_tags` — правило по умолчанию для всех апстримов провайдера;
+- `upstreams[].think_tags` — необязательное переопределение на конкретной
+  апстрим-модели.
+
+Значения (строки):
+
+| Значение | Поведение |
+|---|---|
+| `off` | дефолт: ответ не меняется, теги остаются в `content` |
+| `split` | блоки `<think>…</think>` вырезаются из `content`, их текст уходит в `reasoning_content` |
+| `strip` | блоки вырезаются и выбрасываются — клиент рассуждений не видит |
+
+Разбор значения толерантный: `true` ≡ `split`, `false` ≡ `off`; любое
+неизвестное/пустое значение трактуется как `off` (прокси не падает).
+
+Приоритет резолва — по убыванию специфичности: `upstreams[].think_tags` (самый
+конкретный) → `providers[].think_tags` → `off`. То есть значение апстрима
+перекрывает провайдерское.
+
+```yaml
+providers:
+  - id: minimax
+    url: "https://api.minimax.io/v1"
+    key: "${MINIMAX_API_KEY}"
+    think_tags: split          # дефолт для всех апстримов провайдера
+
+upstreams:
+  - id: minimax-m1
+    provider: minimax
+    model: MiniMax-M1          # наследует split от провайдера
+
+  - id: minimax-text-only
+    provider: minimax
+    model: MiniMax-Text-01
+    think_tags: strip          # переопределение: рассуждения выбрасываем
+```
+
+Работает и в стриме, и в обычном (non-stream) ответе. Тег может прийти
+разрезанным между чанками SSE — прокси держит хвост, который может оказаться
+началом тега, и не отдаёт его клиенту до разрешения, поэтому огрызок тега не
+утечёт. Незакрытый `<think>` в конце потока трактуется как «всё после него —
+рассуждения». Если `content` не строка (мультимодальный массив частей) — ответ
+не трогаем. Без флажка (`off`) ответ идёт байт-в-байт как раньше.
+
+### Нативное поле рассуждений (`reasoning_field`)
+
+Некоторые шлюзы-апстримы (например, **Console Go / deepseek в thinking-режиме**)
+в thinking-режиме **требуют** вернуть им нативное поле рассуждений в **каждом**
+assistant-сообщении истории (не только в тех, что с `tool_calls`). Если его нет —
+апстрим отвечает `400`
+(`The `reasoning_content` in the thinking mode must be passed back to the
+API.`). Клиенты при этом рассуждения держат в своих форматах: `reasoning`
+(строка) и/или `reasoning_details` (массив `{type:"reasoning.text", text, ...}`)
+— а нативное поле `reasoning_content` в истории могут и не передавать.
+(Точно так же делает и сам opencode: для deepseek он добавляет reasoning-часть
+на каждом assistant-сообщении, даже пустую.)
+
+Поля (только на уровне **провайдера**, это свойство шлюза, а не модели):
+
+| Поле | Тип / дефолт | Значение |
+|---|---|---|
+| `providers[].reasoning_field` | строка / отсутствует | Имя нативного поля рассуждений у шлюза-апстрима (пример: `reasoning_content`) |
+| `providers[].reasoning_empty_ok` | булево / `false` | Писать ли пустую строку, если текста рассуждений нет вовсе |
+
+Зачем: при отправке запроса прокси **аддитивно** достраивает это поле в
+**каждом** assistant-сообщении — берёт текст из `reasoning`
+(если это непустая строка), иначе склеивает `reasoning_details[*].text`
+(только элементы без `type` или с `type == "reasoning.text"`, через `"\n"`) и
+записывает в поле `reasoning_field`, **если его там ещё нет**. Существующее
+непустое поле не перезаписывается. Ничего при этом не убирается и не
+переименовывается — клиентский `reasoning`/`reasoning_details` остаются на месте,
+поле просто дополняется. Тронуты только assistant-сообщения; `user`/`tool`/
+`system` не меняются.
+Если текста рассуждений нет вовсе — поле не добавляется, кроме случая
+`reasoning_empty_ok: true` (тогда пишется пустая строка `""`). Если
+`reasoning_field` не задан — тело не меняется вовсе.
+
+```yaml
+providers:
+  - id: opencode
+    url: "https://opencode.ai/zen/go/v1"
+    reasoning_field: reasoning_content   # Console Go / deepseek в thinking-режиме
+    # reasoning_empty_ok: true           # опционально; дефолт false
+```
+
+### Экспоненциальный backoff (`backoff`)
+
+Если апстрим регулярно ошибается (`5xx`/`429`/`402` или сетевые ошибки),
+прокси не бьёт по нему на каждом запросе, а отправляет в **откат**
+(cooldown) — это паттерн экспоненциального бэкоффа / circuit breaker:
+чем дольше сервис молчит, тем дольше мы к нему не ходим. Пока апстрим в
+откате, роутер пропускает его и берёт следующий по списку модели.
+
+| Поле | Тип / дефолт | Значение |
+|---|---|---|
+| `providers[].backoff` | ISO-8601-длительность / отсутствует | Потолок отката **на весь провайдер**: счётчик общий для всех его моделей |
+| `upstreams[].backoff` | ISO-8601-длительность / отсутствует | Потолок отката **на конкретную модель**: счётчик индивидуальный |
+
+**Приоритет — модели.** Если `upstreams[].backoff` задан, у этой модели
+собственный счётчик и потолок (провайдерский `backoff` на неё не действует).
+Если у модели не задан, но задан у провайдера — счётчик общий на провайдера:
+сбой на одной модели охлаждает и все остальные модели этого провайдера.
+Если не задан нигде — backoff для этого апстрима выключен (остаются только
+конкурентность и фейловер).
+
+Поведение:
+
+- **первая** ошибка → отдых 1s; каждая следующая **удваивает** интервал
+  (2s, 4s, 8s, …) до заданного потолка (cap);
+- **успешный** запрос сбрасывает счётчик (откат и удвоение начинаются заново);
+- апстрим в откате пропускается при выборе (лог:
+  `upstream=<id> в backoff-откате (~Ns) — пропускаю`);
+- если **все** апстримы модели в откате — прокси отдаёт `503`
+  (`all upstreams cooling, retry in Ns`) с заголовком `Retry-After: N`
+  (секунд до выхода первого апстрима из отката).
+
+Значение — ISO-8601-длительность: `PT30M` (30 минут), `PT1H15M`, `P1D` (сутки),
+`P1M` (месяц), `P1Y` (год). Годы/месяцы укорачиваются приближённо
+(1 год ≈ 365d, 1 месяц ≈ 30d) — kotlin.time `Duration.parse` не принимает
+Y/M (у них нет фиксированной длины), конфиг-парсер прокси расширяет формат.
+Некорректное значение — предупреждение в лог и поле просто игнорируется.
+
+```yaml
+providers:
+  - id: routerai
+    url: "https://routerai.ru/api/v1"
+    backoff: P1M               # потолок на весь провайдер
+
+upstreams:
+  - id: routerai-gpt4o
+    provider: routerai
+    model: gpt-4o
+    backoff: PT15M             # у модели своё: потолок 15m, провайдерский P1M не действует
+```
+
+При старте выводится, что настроено:
+`[llm-proxy] backoff: upstreams=routerai-gpt4o=PT15M providers=routerai=P1M`.
+
+### Таймаут первого байта стрима (`first_byte_timeout`)
+
+Для `stream=true` запросов прокси следит, чтобы апстрим начал отдавать
+**что-нибудь** (первый байт тела) в течение заданного окна. Если апстрим
+молчит дольше — это трактуется как его сбой: слот конкурентности
+освобождается, ошибка идёт в backoff-откат, и роутер **фейловерит** на
+следующего свободного апстрима модели (при его наличии). Это закрывает
+кейс, когда апстрим принял запрос, но «завис» и никогда не начинает
+стримить.
+
+| Поле | Тип / дефолт | Значение |
+|---|---|---|
+| `providers[].first_byte_timeout` | ISO-8601-длительность / отсутствует | Окно ожидания первого байта для всех моделей провайдера |
+| `upstreams[].first_byte_timeout` | ISO-8601-длительность / отсутствует | Окно для конкретной модели (приоритет над провайдерским) |
+
+**Дефолт** (если не задан нигде): `PT30S`.
+
+**Приоритет — модели.** Если `upstreams[].first_byte_timeout` задан, он
+перекрывает провайдерский; если нет — берётся провайдерский; если нет и там —
+дефолт `PT30S`.
+
+**Отключение:** `PT0S` на провайдере или апстриме отключает watchdog
+для этого апстрима — тогда первый байт ждём без лимита (в рамках общего
+`upstream: request_timeout`, см. ниже).
+
+**Применяется только к `stream=true`.** Для `stream=false` (не-стриминговый
+ответ) действует только общий лимит `UPSTREAM_REQUEST_TIMEOUT_MS` (`5m`) —
+строки SSE там склеиваются в один ответ, и таймаут первого байта к нему
+неприменим.
+
+Поведение:
+
+- watchdog висит **на первом чтении** из тела стрим-ответа; как только
+  пришёл хоть какой-то байт — лимит отключается, дальше стрим читается
+  свободно (вплоть до общего request_timeout);
+- `data: [DONE]` приходит в теле — это уже «первый байт», таймаут не
+  сработает;
+- при срабатывании — лог:
+  `[llm-proxy] chat model=<m> upstream=<id> TIMEOUT: первый байт не пришёл за <N>ms → фейловер`
+  (+ `(backoff: отдых …)` если задан backoff), метрика
+  `llm_proxy_requests_total{result="timeout"}`;
+- закрытие апстримом пустого стрима (EOF без единого байта) — **не** таймаут:
+  это валидный короткий ответ, он проксируется как обычно.
+
+Значение — ISO-8601-длительность, формат как у `backoff` (`PT30S`,
+`PT1M30S`, `P1D`, …).
+
+```yaml
+providers:
+  - id: routerai
+    url: "https://routerai.ru/api/v1"
+    first_byte_timeout: PT30S          # окно для всех моделей провайдера
+
+upstreams:
+  - id: routerai-gpt4o
+    provider: routerai
+    model: gpt-4o
+    first_byte_timeout: PT0S         # у модели watchdog отключён
+```
+
+При старте выводится, что настроено:
+`[llm-proxy] first_byte_timeout: upstreams=routerai-gpt4o=PT0S providers=routerai=PT30S default=PT30S`.
+
+### Фоновый пинг апстримов в откате (`probe_interval`)
+
+Когда апстрим «уходит в аут» надолго (backoff растёт до потолка), без пинга
+он вернётся в ротацию только по истечении интервала отката — это может быть
+минуты простоя, хотя модель уже могла ожить. `probe_interval` включает
+фоновый «пингер»: пока апстрим в backoff-откате, HealthProber каждые
+`probe_interval` шлёт ему минимальный запрос (`2+2=?`, `max_tokens=4`,
+`stream=true`) и слушает первый байт ответа. Как только апстрим ответил —
+его снимают с отката немедленно (`backoff.recordSuccess`), и он возвращается
+в общий пул, не дожидаясь истечения backoff-интервала.
+
+| Поле | Тип / дефолт | Значение |
+|---|---|---|
+| `providers[].probe_interval` | ISO-8601-длительность / отсутствует | Интервал пинга для всех моделей провайдера |
+| `upstreams[].probe_interval` | ISO-8601-длительность / отсутствует | Интервал для конкретной модели (приоритет над провайдерским) |
+
+**Дефолт** (если не задан нигде): `PT1S`.
+
+**Приоритет — модели.** Если `upstreams[].probe_interval` задан, он
+перекрывает провайдерский; если нет — берётся провайдерский; если нет и там —
+дефолт `PT1S`.
+
+**Отключение:** `PT0S` на провайдере или апстриме отключает пинг для этого
+апстрима — тогда он возвращается в пул только по истечении backoff-интервала.
+
+Особенности:
+
+- пингуются **только** апстримы, которые сейчас в backoff-откате; живой
+  апстрим пинг не получает (проверка состояния — каждые `probe_interval`);
+- пинг **не занимает слот конкурентности** (идёт в обход `max_concurrency`),
+  чтобы не отжимать слот у живых запросов;
+- ошибка пинга **не** считается в backoff (иначе каждая попытка удваивала
+  бы интервал отката); учитывается только успех;
+- признак «ответил» — HTTP 2xx и первый байт тела за `first_byte_timeout`
+  (тот же watchdog, что и у обычных запросов);
+- на пинг применяются патчи провайдера и апстрима (как к обычному запросу),
+  чтобы он валидировал реальный путь;
+- при восстановлении — лог:
+  `[llm-proxy] probe upstream=<id> ответил — снят с backoff, вернулся в пул`,
+  метрика `llm_proxy_probe_pings_total{result="ok"}`;
+- при молчании — лог `[llm-proxy] probe upstream=<id> молчит — остаюсь в backoff`,
+  метрика `llm_proxy_probe_pings_total{result="fail"}`.
+
+Значение — ISO-8601-длительность, формат как у `backoff` (`PT1S`, `PT500MS`,
+`PT5S`, …).
+
+```yaml
+providers:
+  - id: routerai
+    url: "https://routerai.ru/api/v1"
+    probe_interval: PT1S           # пингуем все модели провайдера раз в секунду
+
+upstreams:
+  - id: routerai-gpt4o
+    provider: routerai
+    model: gpt-4o
+    probe_interval: PT0S           # у модели пинг отключён (ждать истечения backoff)
+```
+
+При старте выводится, что настроено:
+`[llm-proxy] probe_interval: upstreams=routerai-gpt4o=PT0S providers=routerai=PT1S default=PT1S`.
+
+### Prometheus-метрики (`/metrics`)
+
+Прокси отдаёт pull-метрики в Prometheus text-формате по `GET /metrics`
+(`text/plain; version=0.0.4`), без авторизации (внутренний контур).
+Достаточно включить скрейп в Prometheus/VictoriaMetrics — и в Grafana можно
+вести дашборды использования по провайдерам/моделям и алерты на деградацию.
+
+| Метрика | Тип | Смысл |
+|---|---|---|
+| `llm_proxy_requests_total{model, upstream, provider, result}` | counter | chat-запросы по исходу. `result`: `ok` — успех, `4xx` — ошибка запроса, `429`/`402`/`5xx` — исход с апстрима (каждая фейловер-попытка учитывается отдельно), `net_err` — сетевая ошибка/таймаут, `timeout` — апстрим не прислал первый байт стрима за `first_byte_timeout`, `cancelled` — клиент отвалился посреди стрима |
+| `llm_proxy_probe_pings_total{upstream, provider, result}` | counter | фоновые пинги апстримов в backoff-откате (HealthProber). `result`: `ok` — апстрим ответил (снят с отката), `fail` — молчит (остался в откате) |
+| `llm_proxy_upstream_inflight{upstream, provider}` | gauge | занятые слоты апстрима прямо сейчас (конкурентность) |
+| `llm_proxy_upstream_fail_streak{upstream, provider}` | gauge | счётчик сбоев подряд (backoff): сколько раз подряд упал |
+| `llm_proxy_upstream_cooling_seconds{upstream, provider}` | gauge | сколько секунд апстрим ещё в backoff-откате (0 = жив) |
+
+Метки: `model` — витринное имя модели, `upstream`/`provider` — внутренние id из конфига.
+Метрики live в памяти: при рестарте прокси сбрасываются (серить их будет Prometheus).
+
+Примеры для Grafana:
+- оборот по виртуальным моделям: `sum(rate(llm_proxy_requests_total[5m])) by (model)`;
+- оборот по провайдерам: `sum(rate(llm_proxy_requests_total[5m])) by (provider)`;
+- «провайдер умер»: `llm_proxy_upstream_cooling_seconds > 0` дольше N минут — алерт;
+- доля ошибок провайдера: `sum(rate(llm_proxy_requests_total{result=~"4xx|429|402|5xx|net_err|timeout"}[10m])) by (provider) / sum(rate(llm_proxy_requests_total[10m])) by (provider)`.
+
 ### Пример сборки тела (многослойный `patch`)
 
 Берём модель `my-gpt` (из примера выше), маршрут уходит на апстрим
@@ -209,17 +553,27 @@ data class ProviderConf(
     val id: String,
     val url: String,
     val key: String = "",
-    val max_concurrency: Int? = null, // лимит по умолчанию для апстримов провайдера
-    val patch: JsonObject? = null,    // ко всем запросам провайдера
+    val max_concurrency: Int? = null,
+    val patch: JsonObject? = null,
+    val session_header: String? = null,
+    val think_tags: String? = null,
+    val reasoning_field: String? = null,
+    val reasoning_empty_ok: Boolean = false,
+    val backoff: Duration? = null,          // потолок backoff на провайдера (ISO-8601)
+    val first_byte_timeout: Duration? = null, // окно первого байта стрима (ISO-8601)
+    val probe_interval: Duration? = null,   // интервал фонового пинга (ISO-8601)
 )
 
-@Serializable
 data class UpstreamConf(
     val id: String,                  // наш внутренний id апстрима
     val provider: String,            // ссылка на ProviderConf.id
     val model: String,               // реальное имя модели у провайдера
     val max_concurrency: Int? = null,// опционально; null/0 = безлимит
     val patch: JsonObject? = null,   // к запросам этой апстрим-модели
+    val think_tags: String? = null,  // переопределение think-режима модели
+    val backoff: Duration? = null,   // потолок backoff на модель (приоритет над провайдерским)
+    val first_byte_timeout: Duration? = null, // окно первого байта стрима (приоритет над провайдерским)
+    val probe_interval: Duration? = null, // интервал фонового пинга (приоритет над провайдерским)
 )
 
 @Serializable
@@ -325,7 +679,7 @@ fun release(u: UpstreamConf) = active.getValue(u.id).decrementAndGet()
     `upstream.patch` → `model.patch`), каждый через `merge(...)`; слои с `patch
     == null` пропускаем. Итог — финальное тело запроса;
   - шлём на `provider.url + /chat/completions` с `Authorization: Bearer provider.key`;
-  - при ответе `5xx`/`429` от провайдера — `release(upstream)` и переходим к
+   - при ответе `5xx`/`429`/`402` от провайдера — `release(upstream)` и переходим к
      следующему свободному апстриму из списка (фейловер); исчерпали список —
      отдаём `503` (`all upstreams failed`);
   - при успехе/отмене клиента — `release(upstream)` в `finally` и выходим.
@@ -378,8 +732,18 @@ fun release(u: UpstreamConf) = active.getValue(u.id).decrementAndGet()
   свободному `upstream=<id>`.
 - **Завершение** (успех/ошибка/отмена клиента): длительность, статус апстрима,
   освобождён слот `active[id]=N/limit`.
-- **Ошибка апстрима** (не `5xx`/`429`, а сетевая/таймаут): как сейчас — лог с
+- **Ошибка апстрима** (не `5xx`/`429`/`402`, а сетевая/таймаут): как сейчас — лог с
   сообщением.
+- **Backoff**: при фейловере строка дополняется интервалом отдыха
+  (`(backoff: отдых PT…)`); при пропуске апстрима в откате —
+  `upstream=<id> в backoff-откате (~Ns) — пропускаю`; при старте — список
+  настроенных backoff (`backoff: upstreams=… providers=…`).
+- **Таймаут первого байта стрима**: при срабатывании watchdog'а —
+  `upstream=<id> TIMEOUT: первый байт не пришёл за <N>ms → фейловер`;
+  при старте — список настроенных `first_byte_timeout`
+  (`first_byte_timeout: upstreams=… providers=… default=PT30S`).
+- **Все в откате** — `503 all upstreams cooling, retry in Ns` для
+  `model=<витрина>` с заголовком `Retry-After: N`.
 
 Формат строки лога — один префикс `[llm-proxy]`, как сейчас, чтобы не ломать
 существующий парсинг логов (если он есть).

README.md

@@ -19,6 +19,36 @@ CWD; переопределяется env `CONFIG_PATH`). Блоки: `server` (
 умолчанию для его апстримов), и на апстриме (перекрывает провайдерский); без
 обоих — безлимит.
 
+Обработку think-тегов включает опциональный флажок `think_tags` у провайдера или
+апстрима (`off` по умолчанию, `split` — рассуждения из `think`-тегов уходят
+в `reasoning_content`, `strip` — выбрасываются); работает и в стриме, и в
+non-stream.
+
+Повторяющиеся сбои апстрима увязываются экспоненциальным backoff: поле
+`backoff` (ISO-8601-потолок, напр. `P1M`) задаётся на провайдере (общий
+счётчик на его модели) и/или на апстриме (приоритет). Первая ошибка — отдых
+1s, далее 2s, 4s, … до потолка; успех сбрасывает. Все апстримы модели в откате
+— `503` с `Retry-After`.
+
+Для `stream=true` запросов действует watchdog на первый байт ответа:
+`first_byte_timeout` (ISO-8601, дефолт `PT30S`, `PT0S` отключает) — если
+апстрим не прислал ни одного байта за окно, слот освобождается, ошибка идёт
+в backoff и роутер фейловерит на следующего свободного апстрима. Приоритет:
+`upstreams[].first_byte_timeout` → `providers[].first_byte_timeout` → `PT30S`.
+
+Пока апстрим «отдыхает» в backoff-откате, его можно фоново пинговать:
+`probe_interval` (ISO-8601, дефолт `PT1S`, `PT0S` отключает) — HealthProber
+шлёт апстриму минимальный запрос (`2+2=?`, `max_tokens=4`) и, как только тот
+ответил, снимает его с отката немедленно, не дожидаясь истечения
+backoff-интервала. Пинг не занимает слот конкурентности и не засчитывается
+в backoff. Приоритет: `upstreams[].probe_interval` →
+`providers[].probe_interval` → `PT1S`.
+
+Прокси отдаёт Prometheus-метрики по `GET /metrics` (запросы по
+`model/upstream/provider/result`, занятые слоты, счётчик и окно backoff-отката) —
+подключите скрейп в Prometheus и стройте дашборды/алерты в Grafana. Список
+метрик — в CONFIG.md, раздел «Prometheus-метрики».
+
 | Переменная | Default | Описание |
 |---|---|---|
 | `CONFIG_PATH` | `config.yaml` (CWD) | Путь к YAML-конфигу |

TESTING.md

@@ -0,0 +1,104 @@
+# Тестирование llm-proxy
+
+Все тесты — обычные модульные, живут в `src/commonTest/kotlin/pw/binom/llmproxy/`.
+
+## Запуск
+
+- `./gradlew jvmTest` — прогнать все тесты;
+- `./gradlew clean jvmTest fatJar` — полная сборка с нуля;
+- результат смотреть в `build/test-results/jvmTest/*.xml` (атрибуты `tests`/`failures`/`errors`), потому что строки вида «N tests completed» печатаются только при падениях.
+
+## Что покрыто
+
+| Файл | Что проверяет |
+| --- | --- |
+| `ThinkTagSplitterTest` | Автомат рассечения think-тегов: passthrough при off, вырезание рассуждений при split, отбрасывание при strip, удержание разрезанного тега, несколько блоков, незакрытый блок; |
+| `ConfigLogicTest` | Разбор конфига (`reasoning_field`/`reasoning_empty_ok` провайдера и их дефолты), приоритет источников (апстрим важнее провайдера), слияние патчей, выбор апстрима и лимиты конкурентности, заголовки, сессии; |
+| `ReasoningFieldTest` | Достройка нативного поля рассуждений (`applyReasoningField`/`reasoningTextOf`): форма клиента opencode (`reasoning` + `reasoning_details`), чужой `type` в details, склейка нескольких details, запрет перезаписи непустого поля, заполнение поля на **каждом** assistant-сообщении (с `tool_calls`, без, `tool_calls: []` — без текста и `emptyOk=false` не трогаем; `emptyOk=true` — пустая строка), неприкосновенность `user`/`tool`/`system`, `reasoning_field: null`, отсутствие `messages`, сохранение порядка и прочих полей; |
+| `NullToleranceTest` | Устойчивость разбора ответов апстрима к JSON-`null` (`choices`, `delta.tool_calls`, `delta.content`) — пропуск вместо исключения; |
+| `ThinkTagTransformTest` | Non-stream путь `transformThinkMessage`: перенос рассуждений в `reasoning_content`, дописывание к уже имеющемуся, strip, незакрытый блок, отсутствие изменений → null; |
+| `ThinkTagChunkTest` | SSE-чанки `transformThinkChunk`: удержание хвоста тега между чанками, независимые сплиттеры по index, удаление пустого `content`; |
+| `ThinkTagStreamTest` | Обвязка стрима `streamSseWithThinkTags`: разрез тега между data-событиями, сброс удержанного хвоста в финиш-чанке, прохождение служебных строк и `[DONE]`, битый JSON, чанк без choices, strip. |
+| `StreamDoneContractTest` | Контракт конца SSE: детектор `finish_reason`/`[DONE]` (в т.ч. разрезанных границей чтения), дописывание `data: [DONE]\n\n` в сыром passthrough и в think-обвязке при штатном закрытии без маркера, отсутствие маркера при обрыве без `finish_reason`, отсутствие дублирования. |
+| `BackoffTest` | Экспоненциальный backoff: удвоение интервала отката до потолка (cap), сброс счётчика при успехе, окно охлаждения (`isCoolingAt`/`remainingAt`), ISO-8601-разбор cap (`PT30M`, `P1D`, `PT1M30S`) и конфиг-парсер `parseIsoDuration` (ленивые Y/M: `P1M`≈30d, `P1Y`≈365d; мусор — ошибка), скоупы: общий провайдерский счётчик на все его модели, приоритет `upstreams[].backoff` над провайдерским, независимость скоупов, backoff не настроен → без отката. |
+| `MetricsTest` | `/metrics`: counters по исходам запросов (`ok/4xx/429/402/5xx/net_err/cancelled`), гейджи `inflight`/`fail_streak`/`cooling_seconds` (общий провайдерский скоуп виден в метриках), экранирование меток, маппинг HTTP-статуса → `result`. |
+
+## Проверка качества тестов (мутационная приёмка)
+
+Приём по шагам:
+
+1. Забэкапить файл.
+2. Внести РОВНО одну поломку в боевой код.
+3. Прогнать `./gradlew cleanJvmTest jvmTest`.
+4. Посмотреть XML — тест, который не упал, считается пустым.
+5. Откатить (`git checkout -- <файл>`).
+
+Обязательно: `cleanJvmTest` обязателен, иначе прогон не перезапустится.
+
+Проверенные мутации, каждая из которых ДОЛЖНА ронять тесты:
+
+- `transformThinkMessage` возвращает null → падают тесты non-stream;
+- `transformThinkChunk` возвращает null → падают тесты чанков и стрима;
+- блок финиш-чанка в `streamSseWithThinkTags` не выполняется → падает тест про удержанный хвост;
+- `holdableSuffix` всегда 0 (хвост тега не удерживается) → падают тесты автомата, чанков и стрима;
+- `strip` начинает отдавать рассуждения → падает тест автомата;
+- `missingDoneMarker` всегда `false` → падают тесты сырого пути (`rawStreamIsByteExactAndAppendsDone`) и тест разрезанного маркера;
+- `if (sawFinishReason && !sawDone)` → `if (!sawDone)` в `streamSseWithThinkTags` → падает `thinkStreamTruncatedNeedsNoMarker`;
+- `if (sawFinishReason && !sawDone)` → `if (false)` в `streamSseWithThinkTags` → падает `thinkStreamAppendsDoneWhenUpstreamClosedWithoutMarker`.
+
+Правило: боевой код нельзя подгонять под тест; если тест не проходит, неверен тест.
+
+## Поле рассуждений для Console Go (релиз 11) — замеры приёмки
+
+Причина правки: апстрим `deepseek-v4.1-flash` у провайдера `opencode` (Console Go) в thinking-режиме
+требует `reasoning_content` в assistant-сообщениях с `tool_calls`, а клиент opencode присылает
+рассуждения как `reasoning` + `reasoning_details` — отсюда `400 The reasoning_content in the
+thinking mode must be passed back to the API`.
+
+**Границы требования (замер прямыми запросами к Console Go, одинаковое тело):**
+
+| assistant-сообщение | HTTP |
+| --- | --- |
+| с `tool_calls`, без reasoning вовсе | 400 |
+| с `tool_calls`, `reasoning` + `reasoning_details` (форма opencode) | 400 |
+| с `tool_calls`, только `reasoning_details` | 400 |
+| с `tool_calls`, `reasoning_content` + `reasoning` + `reasoning_details` (аддитивно) | 200 |
+| с `tool_calls`, `reasoning_content: ""` | 200 |
+| без `tool_calls`, без reasoning | 200 |
+
+**Живая приёмка (локальный инстанс на 8101, конфиг-копия боевого, модель с единственным апстримом
+Console Go; тело — как у opencode: assistant + `reasoning` + `reasoning_details` + `tool_calls`):**
+
+| Конфиг | `stream=false` | `stream=true` |
+| --- | --- | --- |
+| без правки (`reasoning_field` не задан) | **400** — та самая ошибка про `reasoning_content` | **400** |
+| с правкой (`reasoning_field: reasoning_content`) | **200**, модель продолжила диалог после tool-результата | **200** |
+
+**Регрессия на боевых цепочках (тот же инстанс, то же тело с `tool_calls`):** `codding-big` → 200
+(ушло на `minimax-m3`, поле не добавляется — флаг объявлен только у провайдера `opencode`),
+`codding` → 200 (`qwen-3.8`, local), `assistant` → 200 (Console Go с правкой).
+
+**Мутационная приёмка:** 4 мутации из ТЗ отработал кодер, две проверены вручную
+(`cleanAllTests jvmTest`): снятие охраны `tool_calls` в `applyReasoningField` → падают
+`assistantWithoutToolCallsIsUntouched` и `assistantWithEmptyToolCallsIsUntouched`;
+возврат `obj["choices"]?.jsonArray` в `rebuildFromChunks` → падает `rebuildFromChunksToleratesNullChoices`.
+
+**Поправка после боевого 400 (2026-09-13):** живые stateful-сессии Console Go
+(сессия, где глюч уже видел thinking-ответы) всё-таки требовали
+`reasoning_content` и на assistant-сообщениях **без** `tool_calls` — свежая
+сессия такой истории прощала (все формы выше — 200). Опция «на каждом
+assistant-сообщении» совпадает с тем, что делает сам opencode («Deepseek
+requires all assistant messages to have reasoning on them», пустая
+reasoning-часть дописывается тоже). Охрана `tool_calls` в
+`applyReasoningField` снята: поле дописывается на каждом assistant-сообщении
+(текст — из `reasoning`/`reasoning_details`, при `emptyOk` — пустая строка).
+Тесты `assistantWithoutToolCallsIsUntouched`/`assistantWithEmptyToolCallsIsUntouched`
+заменены на `assistantWithoutToolCallsAlsoGetsField`,
+`assistantWithoutReasoningAndNoEmptyOkIsUntouched`,
+`assistantWithoutToolCallsWithEmptyOkFillsEmpty`, `assistantWithEmptyToolCallsGetsField`.
+
+## Известное ограничение
+
+Живой стрим в реальном апстриме модульными тестами не проверяется: обвязка испытывается на синтетическом SSE через каналы ktor. Реальный апстрим проверяется только после деплоя.
+Правка поля рассуждений — исключение: она проверена живым инстансом против настоящего Console Go (таблица выше) до релиза.
+

build.gradle.kts

@@ -31,6 +31,7 @@ kotlin {
         val commonTest by getting {
             dependencies {
                 implementation(libs.kotlin.test)
+                implementation(libs.kotlinx.coroutines.test)
             }
         }
         val jvmMain by getting {

docs/sse-done-contract.md

@@ -0,0 +1,280 @@
+# ТЗ: выравнивание контракта конца SSE (дописать `data: [DONE]`)
+
+Задача-источник: Vikunja **#71** («в opencode модель додумала, идёт ожидание ~45 с»).
+
+## 1. Что происходит сейчас (проверено живыми замерами 11.09.2026)
+
+Цепочка: opencode → `llm.binom.pw` (Bifrost v1.5.0) → `llm-proxy:8100` → `api.minimax.io`.
+
+- **MiniMax не присылает терминатор `data: [DONE]`.** После чанка с `finish_reason: "stop"` он просто закрывает
+  сокет (сразу). Проверено и с `reasoning_split`, и с `stream_options.include_usage`.
+- **llm-proxy отдаёт поток корректно**, но клиент ждёт маркер: при `think_tags: off` (это как раз MiniMax-апстрим
+  `minimax-m3` модели `codding-big`) работает сырой байтовый passthrough — что прислал апстрим, то и ушло.
+  Маркера нет → нет маркера.
+- **Bifrost v1.5.0** для custom-провайдеров считает `[DONE]` обязательным (`ProviderSendsDoneMarker` = true;
+  флага `custom_provider_config.does_not_send_done_marker` в этой версии нет). Маркера нет → его цикл чтения
+  не завершается, и стрим закрывается только когда умирает keep-alive-сокет llm-proxy — через **45.00 с**
+  (Ktor CIO `connectionIdleTimeoutSeconds = 45`). После этого Bifrost дописывает клиенту `[DONE]` и закрывает поток.
+  Отсюда «модель додумала, а opencode ещё думает».
+- Контроль: тот же Bifrost и та же тула, апстрим со своим `[DONE]` (RouterAI `local/deepseek/deepseek-v4-flash-0731`)
+  — закрытие за **0.00 с**.
+
+## 2. Требуемое поведение (контракт)
+
+Стрим, который отдаёт llm-proxy клиенту, **всегда** заканчивается маркером `data: [DONE]\n\n`, если апстрим
+завершил поток штатно (в потоке был непустой `finish_reason`), — даже когда сам апстрим маркер не прислал.
+
+Правило ровно в двух частях:
+
+1. Апстрим закрыл поток, и в потоке был непустой `finish_reason`, но `data: [DONE]` мы не видели →
+   дописать клиенту `data: [DONE]\n\n` и `flush()`.
+2. Апстрим оборвался, **не** прислав `finish_reason` (усечённый/битый поток) → маркер **НЕ** дописывать,
+   отдать как есть.
+
+Пункт 2 — не забыть и не «улучшить»: именно по отсутствию маркера Bifrost отличает усечённый стрим от
+успешного (его детект `SSEStreamEndedOnMarker`). Если дописать маркер при обрыве без `finish_reason`,
+мы превратим обрыв в «успех» и сломаем диагностику.
+
+Обязательно: **байты уже существующих чанков не меняются** (passthrough остаётся byte-exact), маркер
+дописывается только В КОНЦЕ, только один раз, и никогда не дублируется, если апстрим прислал свой.
+
+## 3. Правки в коде
+
+Файл **один**: `src/commonMain/kotlin/pw/binom/llmproxy/Main.kt`.
+
+### 3.1. Константы и хелперы (добавить рядом с блоком think-хелперов)
+
+```kotlin
+/** Терминальный маркер SSE, который клиенты (в т.ч. Bifrost) ждут как конец потока. */
+private const val SSE_DONE_MARKER = "data: [DONE]\n\n"
+
+/** Размер скользящего окна детектора: маркер может разрезаться границей чтения. */
+private const val STREAM_SCAN_WINDOW = 128
+
+/**
+ * Есть ли в тексте `finish_reason` со значением, отличным от `null`. Экранированные
+ * вхождения (`\"finish_reason\\\":\\\"stop\\\"` внутри содержимого ответа) не считаются:
+ * смотрим только на неэкранированную кавычку.
+ */
+internal fun hasNonNullFinishReasonText(text: String): Boolean {
+    var from = 0
+    while (true) {
+        val i = text.indexOf("finish_reason", from)
+        if (i < 0) return false
+        val quote = i - 1
+        val escaped = quote >= 0 && text[quote] == '"' && quote > 0 && text[quote - 1] == '\\'
+        if (!escaped) {
+            val rest = text.substring(i + "finish_reason".length)
+                .dropWhile { it == ' ' || it == ':' || it == '"' }
+            if (!rest.startsWith("null")) return true
+        }
+        from = i + 1
+    }
+}
+
+/** Структурная проверка чанка: в `choices[*].finish_reason` есть непустая строка. */
+internal fun hasFinishReason(obj: JsonObject): Boolean =
+    obj["choices"]?.jsonArray?.any { el ->
+        val fr = (el.jsonObject["finish_reason"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+        !fr.isNullOrEmpty()
+    } ?: false
+
+/**
+ * Детектор контракта конца SSE для сырого passthrough-потока (`think_tags: off`).
+ * Копит скользящее окно последних байт, чтобы маркер `finish_reason`/`[DONE]`,
+ * разрезанный границей чтения, всё равно был распознан, и запоминает два факта:
+ * видели ли непустой `finish_reason` и видели ли `[DONE]`.
+ */
+internal class StreamEndDetector(private val windowSize: Int = STREAM_SCAN_WINDOW) {
+    var sawFinishReason = false
+        private set
+
+    var sawDone = false
+        private set
+
+    private var window: String = ""
+
+    fun feed(bytes: ByteArray, from: Int = 0, length: Int = bytes.size) {
+        if (length <= 0) return
+        val scan = window + bytes.decodeToString(from, from + length)
+        if (!sawDone && scan.contains("[DONE]")) sawDone = true
+        if (!sawFinishReason && hasNonNullFinishReasonText(scan)) sawFinishReason = true
+        window = if (scan.length > windowSize) scan.substring(scan.length - windowSize) else scan
+    }
+
+    /**
+     * Маркер нужен, только если апстрим закрыл поток после штатного `finish_reason`,
+     * но сам `[DONE]` не прислал. При обрыве БЕЗ `finish_reason` маркер НЕ дописываем.
+     */
+    val missingDoneMarker: Boolean get() = sawFinishReason && !sawDone
+}
+
+/**
+ * Сырой байтовый passthrough стрима (`think_tags: off`) с выравниванием контракта
+ * конца потока: байты уходят клиенту как есть, а если апстрим закрыл поток, не
+ * прислав `data: [DONE]`, но `finish_reason` в потоке был — дописываем маркер.
+ */
+internal suspend fun ByteWriteChannel.streamRawWithDoneContract(source: ByteReadChannel) {
+    val detector = StreamEndDetector()
+    val buf = ByteArray(8192)
+    while (true) {
+        val n = source.readAvailable(buf)
+        if (n == -1) break
+        if (n > 0) {
+            writeFully(buf, 0, n)
+            flush()
+            detector.feed(buf, 0, n)
+        }
+    }
+    if (detector.missingDoneMarker) {
+        emitUtf8(SSE_DONE_MARKER)
+        flush()
+    }
+}
+```
+
+Импорты под новые типы (`ByteReadChannel`, `ByteWriteChannel`, `readAvailable`, `writeFully`, `flush`,
+`jsonArray`, `jsonObject`, `JsonPrimitive`) — проверить, что они уже есть в файле; добавлять только недостающие.
+
+### 3.2. Правка ветки `think_tags: off` в `handleChat`
+
+Было (внутри `call.respondBytesWriter(...)`):
+
+```kotlin
+if (thinkMode == "off") {
+    // Флажок не выставлен — сырой байтовый passthrough как раньше.
+    val buf = ByteArray(8192)
+    while (true) {
+        val n = ch.readAvailable(buf)
+        if (n == -1) break
+        if (n > 0) {
+            writeFully(buf, 0, n)
+            flush()
+        }
+    }
+} else {
+    streamSseWithThinkTags(ch, thinkMode)
+}
+```
+
+Стало:
+
+```kotlin
+if (thinkMode == "off") {
+    // Флажок не выставлен — сырой байтовый passthrough + выравнивание конца потока.
+    ch.streamRawWithDoneContract(this)
+} else {
+    streamSseWithThinkTags(ch, thinkMode)
+}
+```
+(если `this` в этом контексте — не `ByteWriteChannel`, использовать тот ресивер, который уже использовался
+существующими вызовами `writeFully`/`flush` в этой лямбде; компилятор — источник истины).
+
+### 3.3. Правка `streamSseWithThinkTags`
+
+Добавить два флага и запись фактов:
+
+```kotlin
+internal suspend fun ByteWriteChannel.streamSseWithThinkTags(source: ByteReadChannel, thinkMode: String) {
+    val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+    val addReasoning = thinkMode == "split"
+    var sawDone = false
+    var sawFinishReason = false
+    while (true) {
+        val line = source.readLine(LineEnding.Lenient) ?: break
+        when {
+            line.startsWith("data:") -> {
+                val payload = line.removePrefix("data:").trim()
+                if (payload == "[DONE]") {
+                    sawDone = true
+                    emitUtf8(SSE_DONE_MARKER)
+                } else {
+                    val obj = runCatching { json.parseToJsonElement(payload).jsonObject }.getOrNull()
+                    if (obj != null && hasFinishReason(obj)) sawFinishReason = true
+                    val out = obj?.let { transformThinkChunk(it, splitters, thinkMode, addReasoning) }
+                    if (out == null) emitUtf8("$line\n\n") else emitUtf8("data: $out\n\n")
+                }
+            }
+            else -> emitUtf8("$line\n")
+        }
+        flush()
+    }
+    // ... существующий блок сброса удержанных хвостов сплиттеров — БЕЗ изменений ...
+    // НОВОЕ: после хвостов дописать маркер, если апстрим его не прислал, а finish_reason был.
+    if (sawFinishReason && !sawDone) {
+        emitUtf8(SSE_DONE_MARKER)
+        flush()
+    }
+}
+```
+
+Порядок важен: маркер дописывается **после** блока сброса хвостов (сначала текст, потом терминатор).
+Остальную логику функции (`transformThinkChunk`, `emitUtf8("$line\n")` для служебных строк) не менять.
+
+## 4. Тесты (новый файл)
+
+`src/commonTest/kotlin/pw/binom/llmproxy/StreamDoneContractTest.kt` — по образцу существующего
+`ThinkTagStreamTest` (тот же приём: `ByteChannel(autoFlush = true)`, запись входа, `close(null)`,
+чтение выхода в буфер; для сырого потока вызывать `streamRawWithDoneContract`).
+
+Обязательные случаи (имена — как ниже, чтобы можно было ссылаться в отчёте):
+
+| Тест | Вход | Ожидание |
+| --- | --- | --- |
+| `textHelperSeesFinishReason` | строка `{"choices":[{"finish_reason":"stop"}]}` | `hasNonNullFinishReasonText` = true |
+| `textHelperIgnoresNullFinishReason` | `{"choices":[{"finish_reason":null}]}` | false |
+| `textHelperIgnoresEscapedOccurrenceInContent` | `{"delta":{"content":"\"finish_reason\":\"stop\""}}` | false |
+| `detectorSeesFinishReasonSplitAcrossReads` | два `feed`: `...finish_rea` + `son":"stop"...` | `sawFinishReason` = true, `missingDoneMarker` = true |
+| `detectorSeesDoneSplitAcrossReads` | два `feed`: `data: [DO` + `NE]` | `sawDone` = true, `missingDoneMarker` = false |
+| `detectorSeesDoneAndFinishReason` | `finish_reason` + `[DONE]` в одном feed | `missingDoneMarker` = false |
+| `detectorTruncatedStreamNeedsNoMarker` | `feed` с контентом без `finish_reason` | `missingDoneMarker` = false |
+| `rawStreamIsByteExactAndAppendsDone` | SSE с `finish_reason`, без `[DONE]` | выход = вход + `"data: [DONE]\n\n"` (байт-в-байт префикс), маркер ровно один |
+| `rawStreamTruncatedPassesThroughUntouched` | SSE без `finish_reason` и без `[DONE]` | выход = вход (ни одного `[DONE]`) |
+| `rawStreamKeepsUpstreamDoneMarker` | SSE с `finish_reason` и своим `[DONE]` | `[DONE]` ровно один (не дублируется) |
+| `thinkStreamAppendsDoneWhenUpstreamClosedWithoutMarker` | `streamSseWithThinkTags(..., "split")`, чанк с `finish_reason:"stop"`, без `[DONE]` | выход заканчивается `data: [DONE]\n\n`, ровно один маркер |
+| `thinkStreamTruncatedNeedsNoMarker` | mode `split`, чанк с контентом, без `finish_reason` | в выходе нет `[DONE]` |
+| `thinkStreamKeepsSingleDone` | mode `split`, `finish_reason` + `data: [DONE]` | ровно один `[DONE]` |
+
+## 5. Мутационная приёмка (по TESTING.md)
+
+После того как тесты зелёные, проверить их силу — по одному изменению, каждый раз с
+`./gradlew cleanJvmTest jvmTest`, затем `git checkout --` на файл:
+
+1. `missingDoneMarker` → всегда `false` (детектор сырого пути) — должны упасть тесты сырого пути
+   (`rawStreamIsByteExactAndAppendsDone`) и тест разрезанного маркера;
+2. `if (sawFinishReason && !sawDone)` → `if (!sawDone)` в `streamSseWithThinkTags` — должен упасть
+   `thinkStreamTruncatedNeedsNoMarker` (это защита от «обрыв выглядит как успех»);
+3. `if (sawFinishReason && !sawDone)` → `if (false)` — должен упасть
+   `thinkStreamAppendsDoneWhenUpstreamClosedWithoutMarker`.
+
+Тест, который при такой поломке остаётся зелёным, считается пустым.
+
+## 6. Команды проверки
+
+```bash
+./gradlew jvmTest                        # все тесты зелёные; сейчас в проекте 66 тестов, стало больше
+./gradlew cleanJvmTest jvmTest           # прогон с нуля (обязателен для мутационной приёмки)
+./gradlew clean jvmTest fatJar           # полная сборка
+```
+Числа тестов смотреть в `build/test-results/jvmTest/*.xml` (атрибуты `tests` / `failures` / `errors`),
+а не по строкам в консоли.
+
+## 7. Границы работ
+
+- Трогать **только**: `src/commonMain/kotlin/pw/binom/llmproxy/Main.kt`,
+  `src/commonTest/kotlin/pw/binom/llmproxy/StreamDoneContractTest.kt`, `TESTING.md` (добавить строку про
+  новый тест-файл и пункты мутационной приёмки).
+- **НЕ** менять `ThinkTagSplitter.kt`, non-stream путь, `transformThinkMessage`, `transformThinkChunk`,
+  фрейминг существующих чанков, `README.md`/`CONFIG.md`.
+- **НЕ** добавлять зависимости, не менять версии в `build.gradle.kts`, не менять `config.yaml`.
+- **НЕ** коммитить и не пушить.
+- Внешние сети/апстримы не дёргать — только локальные тесты.
+
+## 8. Вне области (и почему)
+
+- **Обрыв без `finish_reason` остаётся без маркера** — так усечённый стрим не выглядит успешным
+  (см. п. 2). Да, в этом случае Bifrost снова будет ждать закрытия сокета; это осознанный выбор
+  в пользу честности контракта, а не «ускорения любой ценой».
+- **Non-stream путь** не трогаем: там тула сама собирает ответ из чанков (`rebuildFromChunks`) и
+  маркер не нужен.
+- **Bifrost и сам MiniMax** не трогаем: фикс на нашем хопе лечит всех клиентов сразу.

gradle/libs.versions.toml

@@ -19,6 +19,7 @@ kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serializa
 yamlkt = { module = "net.mamoe.yamlkt:yamlkt", version.ref = "yamlkt" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "datetime" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
 kotlinx-io-core = { module = "org.jetbrains.kotlinx:kotlinx-io-core", version.ref = "kotlinxIo" }
 logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test" }

src/commonMain/kotlin/pw/binom/llmproxy/Backoff.kt

@@ -0,0 +1,124 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlin.concurrent.Volatile
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Экспоненциальный бэкофф для одной области отдыха: первая ошибка — отдых
+ * [base] (1 с), каждая следующая удваивает интервал вплоть до [cap].
+ * Успешный запрос сбрасывает счётчик и отдых.
+ */
+class BackoffGuard(val cap: Duration, val base: Duration = 1.seconds) {
+    private val lock = Mutex()
+    @Volatile
+    private var failures: Int = 0
+    @Volatile
+    private var interval: Duration = Duration.ZERO
+    @Volatile
+    private var coolingUntil: Instant = Instant.DISTANT_PAST
+
+    fun isCoolingAt(now: Instant): Boolean = now < coolingUntil
+
+    /** Сколько осталось до выхода из отдыха (0 — не в откате). */
+    fun remainingAt(now: Instant): Duration =
+        if (coolingUntil > now) coolingUntil - now else Duration.ZERO
+
+    /** Учёт ошибки; возвращает интервал, на который область уходит в отдых. */
+    suspend fun recordFailure(now: Instant): Duration {
+        lock.lock()
+        try {
+            failures++
+            interval = if (failures == 1) base else interval * 2
+            if (interval > cap) interval = cap
+            coolingUntil = now + interval
+        } finally {
+            lock.unlock()
+        }
+        return interval
+    }
+
+    /** Успех: сброс счётчика и отдыха. */
+    suspend fun recordSuccess() {
+        lock.lock()
+        try {
+            failures = 0
+            interval = Duration.ZERO
+            coolingUntil = Instant.DISTANT_PAST
+        } finally {
+            lock.unlock()
+        }
+    }
+
+    /** Текущая серия сбоев подряд (0 — после успеха или без сбоев). */
+    fun failStreak(): Int = failures
+}
+
+/**
+ * Реестр областей бэкофф-отдыха. Область апстрима:
+ * - у модели (записи upstreams) задан `backoff` — свой счётчик и потолок (приоритет);
+ * - иначе у провайдера задан `backoff` — общий для всех моделей провайдера счётчик;
+ * - ни там, ни там — бэкофф для этого апстрима выключен.
+ */
+class BackoffRegistry(
+    private val providers: Map<String, ProviderConf>,
+    private val upstreams: Map<String, UpstreamConf>,
+) {
+    private val upstreamGuards = mutableMapOf<String, BackoffGuard>()
+    private val providerGuards = mutableMapOf<String, BackoffGuard>()
+    private val lock = Mutex()
+
+    private fun guardForLocked(up: UpstreamConf): BackoffGuard? {
+        up.backoff?.let { cap ->
+            return upstreamGuards.getOrPut(up.id) { BackoffGuard(cap) }
+        }
+        providers[up.provider]?.backoff?.let { cap ->
+            return providerGuards.getOrPut(up.provider) { BackoffGuard(cap) }
+        }
+        return null
+    }
+
+    private suspend fun <T> locked(block: () -> T?): T? {
+        lock.lock()
+        return try {
+            block()
+        } finally {
+            lock.unlock()
+        }
+    }
+
+    suspend fun isCooling(up: UpstreamConf): Boolean {
+        val g = locked { guardForLocked(up) } ?: return false
+        return g.isCoolingAt(Clock.System.now())
+    }
+
+    /** Секунд до выхода апстрима из отдыха (0 — не в откате); дробный остаток округляется вверх. */
+    suspend fun remainingSeconds(up: UpstreamConf): Long {
+        val g = locked { guardForLocked(up) } ?: return 0L
+        val remaining = g.remainingAt(Clock.System.now())
+        if (remaining <= Duration.ZERO) return 0L
+        val s = remaining.inWholeSeconds
+        val isExact = remaining.inWholeNanoseconds == s * 1_000_000_000L
+        return if (isExact) s else s + 1
+    }
+
+    /** Учёт ошибки; возвращает интервал отдыха, или null, если бэкофф для апстрима выключен. */
+    suspend fun recordFailure(up: UpstreamConf): Duration? {
+        val g = locked { guardForLocked(up) } ?: return null
+        return g.recordFailure(Clock.System.now())
+    }
+
+    /** Успех: сброс области апстрима. */
+    suspend fun recordSuccess(up: UpstreamConf) {
+        locked { guardForLocked(up) }?.recordSuccess()
+    }
+
+    /** Текущая серия сбоев апстрима (0 — нет сбоев или backoff не настроен). */
+    suspend fun failStreakOf(up: UpstreamConf): Int {
+        val g = locked { guardForLocked(up) } ?: return 0
+        return g.failStreak()
+    }
+}

src/commonMain/kotlin/pw/binom/llmproxy/HealthProber.kt

@@ -0,0 +1,133 @@
+package pw.binom.llmproxy
+
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.headers
+import io.ktor.client.request.preparePost
+import io.ktor.client.request.setBody
+import io.ktor.utils.io.ByteReadChannel
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlin.time.Duration
+
+/**
+ * Фоновый «пингер» апстримов, которые в данный момент в backoff-откате.
+ *
+ * Пока апстрим молчит (в откате), HealthProber раз в [interval] шлёт ему
+ * минимальный chat.completion (`2+2=?`, `max_tokens=4`) и слушает первый байт
+ * ответа. Как только апстрим ответил — вызывается [BackoffRegistry.recordSuccess],
+ * и он возвращается в общий пул сразу, не дожидаясь истечения backoff-интервала.
+ * Это ускоряет восстановление после долгого простоя провайдера.
+ *
+ * Пинг НЕ занимает слот конкурентности ([UpstreamCounter]) — он идёт в обход,
+ * чтобы не отжимать слот у живых запросов. Ошибки пинга НЕ считаются в backoff
+ * (иначе каждая попытка удваивала бы интервал отката); считается только успех.
+ */
+class HealthProber(
+    private val providersById: Map<String, ProviderConf>,
+    private val upstreams: List<UpstreamConf>,
+    private val http: HttpClient,
+    private val backoff: BackoffRegistry,
+    private val metrics: MetricsRegistry,
+    private val scope: CoroutineScope,
+) {
+    private val jobs = mutableMapOf<String, Job>()
+
+    /** Запустить пинг-корутины для всех апстримов с включённым пингом. */
+    fun start() {
+        for (up in upstreams) {
+            val interval = effectiveProbeInterval(up, providersById[up.provider])
+            if (interval != null) {
+                jobs[up.id] = scope.launch { probeLoop(up, interval) }
+            }
+        }
+    }
+
+    /** Цикл пинга одного апстрима: пингуем только пока он в откате. */
+    internal suspend fun probeLoop(up: UpstreamConf, interval: Duration, pingImpl: suspend (UpstreamConf) -> Boolean = ::ping) {
+        while (currentCoroutineContext().isActive) {
+            if (backoff.isCooling(up)) {
+                val healthy = pingImpl(up)
+                metrics.recordProbe(up, if (healthy) "ok" else "fail")
+                if (healthy) {
+                    backoff.recordSuccess(up)
+                    log.info { "[llm-proxy] probe upstream=${up.id} ответил — снят с backoff, вернулся в пул" }
+                } else {
+                    log.info { "[llm-proxy] probe upstream=${up.id} молчит — остаюсь в backoff" }
+                }
+            }
+            delay(interval)
+        }
+    }
+
+    /** Одна пинг-попытка: минимальный stream-запрос, слушаем первый байт. */
+    private suspend fun ping(up: UpstreamConf): Boolean {
+        val provider = providersById[up.provider] ?: return false
+        val url = provider.url.trimEnd('/') + "/chat/completions"
+        val providerKey = resolveEnv(provider.key)
+        val body = buildProbeBody(up, provider)
+        val firstByteTimeout = effectiveFirstByteTimeout(up, provider) ?: DEFAULT_FIRST_BYTE_TIMEOUT
+        return try {
+            http.preparePost(url) {
+                headers {
+                    if (providerKey.isNotEmpty()) {
+                        set("Authorization", "Bearer $providerKey")
+                    }
+                    set("Content-Type", "application/json")
+                }
+                setBody(body.toString())
+            }.execute { resp ->
+                if (resp.status.value !in 200..299) {
+                    return@execute false
+                }
+                val ch = resp.body<ByteReadChannel>()
+                val buf = ByteArray(64)
+                readAvailableWithTimeout(ch, buf, firstByteTimeout.inWholeMilliseconds) > 0
+            }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            log.info { "[llm-proxy] probe upstream=${up.id} ошибка: ${e.message}" }
+            false
+        }
+    }
+}
+
+/**
+ * Собрать тело пинг-запроса: минимальный chat.completion, на который любой
+ * живой апстрим ответит сразу. Применяются патчи провайдера и апстрима (в том
+ * же порядке, что и для реальных запросов), чтобы пинг валидировал реальный
+ * путь запроса, но без клиентских данных и модели.
+ */
+internal fun buildProbeBody(up: UpstreamConf, provider: ProviderConf?): JsonObject {
+    val base = JsonObject(
+        mapOf(
+            "model" to JsonPrimitive(up.model),
+            "messages" to JsonArray(
+                listOf(
+                    JsonObject(
+                        mapOf(
+                            "role" to JsonPrimitive("user"),
+                            "content" to JsonPrimitive("2+2=?"),
+                        ),
+                    ),
+                ),
+            ),
+            "max_tokens" to JsonPrimitive(4),
+            "stream" to JsonPrimitive(true),
+        ),
+    )
+    var acc = base
+    listOf(provider?.patch, up.patch).filterNotNull().forEach { patch ->
+        acc = merge(acc, patch)
+    }
+    return acc
+}

src/commonMain/kotlin/pw/binom/llmproxy/Main.kt

@@ -3,7 +3,9 @@ package pw.binom.llmproxy
 import io.ktor.client.HttpClient
 import io.ktor.client.call.body
 import io.ktor.client.request.headers
+import io.ktor.utils.io.LineEnding
 import io.ktor.utils.io.readAvailable
+import io.ktor.utils.io.readLine
 import io.ktor.http.Headers
 import io.ktor.client.request.preparePost
 import io.ktor.client.request.setBody
@@ -14,7 +16,9 @@ import io.ktor.server.application.Application
 import io.ktor.server.application.ApplicationCall
 import io.ktor.server.application.call
 import io.ktor.server.application.install
+import io.ktor.server.request.httpMethod
 import io.ktor.server.request.receiveText
+import io.ktor.server.request.uri
 import io.ktor.server.response.respondBytesWriter
 import io.ktor.server.response.respondText
 import io.ktor.server.routing.get
@@ -24,6 +28,14 @@ import io.ktor.utils.io.ByteReadChannel
 import io.ktor.utils.io.ByteWriteChannel
 import io.ktor.utils.io.writeFully
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.selects.onTimeout
+import kotlinx.coroutines.selects.select
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.datetime.Clock
 import kotlinx.serialization.Serializable
@@ -42,6 +54,10 @@ import net.mamoe.yamlkt.YamlList
 import net.mamoe.yamlkt.YamlLiteral
 import net.mamoe.yamlkt.YamlMap
 import kotlin.concurrent.Volatile
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.TimeSource
 
@@ -82,11 +98,33 @@ fun main() {
     val active = config.upstreams.associate { up ->
         up.id to UpstreamCounter(effectiveConcurrencyLimit(up, providersById[up.provider]))
     }
+    val backoff = BackoffRegistry(providersById, upstreamsById)
+    val metrics = MetricsRegistry()
 
     log.info {
         "[llm-proxy] загружено: providers=${config.providers.size}, " +
             "upstreams=${config.upstreams.size}, models=${config.models.size} (config=$path)"
     }
+    log.info {
+        "[llm-proxy] backoff: upstreams=" +
+            config.upstreams.filter { it.backoff != null }.map { up -> "${up.id}=${up.backoff?.toIsoString()}" }.joinToString(", ") +
+            " providers=" +
+            config.providers.filter { it.backoff != null }.map { p -> "${p.id}=${p.backoff?.toIsoString()}" }.joinToString(", ")
+    }
+    log.info {
+        "[llm-proxy] first_byte_timeout: upstreams=" +
+            config.upstreams.filter { it.first_byte_timeout != null }.map { up -> "${up.id}=${up.first_byte_timeout?.toIsoString()}" }.joinToString(", ") +
+            " providers=" +
+            config.providers.filter { it.first_byte_timeout != null }.map { p -> "${p.id}=${p.first_byte_timeout?.toIsoString()}" }.joinToString(", ") +
+            " default=${DEFAULT_FIRST_BYTE_TIMEOUT.toIsoString()}"
+    }
+    log.info {
+        "[llm-proxy] probe_interval: upstreams=" +
+            config.upstreams.filter { it.probe_interval != null }.map { up -> "${up.id}=${up.probe_interval?.toIsoString()}" }.joinToString(", ") +
+            " providers=" +
+            config.providers.filter { it.probe_interval != null }.map { p -> "${p.id}=${p.probe_interval?.toIsoString()}" }.joinToString(", ") +
+            " default=${DEFAULT_PROBE_INTERVAL.toIsoString()}"
+    }
     log.info {
         "[llm-proxy] server: bind host=${config.server.host} port=${config.server.port}"
     }
@@ -95,8 +133,11 @@ fun main() {
     }
 
     val http = createHttpClient()
+    val sessions = SessionRegistry()
+    val prober = HealthProber(providersById, config.upstreams, http, backoff, metrics, CoroutineScope(SupervisorJob() + Dispatchers.Default))
+    prober.start()
     startServer(config.server.host, config.server.port) {
-        proxyModule(config, providersById, upstreamsById, active, http)
+        proxyModule(config, providersById, upstreamsById, active, sessions, http, backoff, metrics)
     }
 }
 
@@ -107,11 +148,21 @@ fun Application.proxyModule(
     providersById: Map<String, ProviderConf>,
     upstreamsById: Map<String, UpstreamConf>,
     active: Map<String, UpstreamCounter>,
+    sessions: SessionRegistry,
     http: HttpClient,
+    backoff: BackoffRegistry,
+    metrics: MetricsRegistry,
 ) {
     routing {
+        get("/metrics") {
+            call.respondText(
+                metrics.render(config, active, backoff),
+                ContentType.parse("text/plain; version=0.0.4"),
+                HttpStatusCode.OK,
+            )
+        }
         post("/v1/chat/completions") {
-            handleChat(call, config, providersById, upstreamsById, active, http)
+            handleChat(call, config, providersById, upstreamsById, active, sessions, http, backoff, metrics)
         }
         get("/v1/models") {
             handleModels(call, config)
@@ -125,8 +176,12 @@ private suspend fun handleChat(
     providersById: Map<String, ProviderConf>,
     upstreamsById: Map<String, UpstreamConf>,
     active: Map<String, UpstreamCounter>,
+    sessions: SessionRegistry,
     http: HttpClient,
+    backoff: BackoffRegistry,
+    metrics: MetricsRegistry,
 ) {
+    log.info { "[llm-proxy] chat ${call.request.httpMethod.value} ${call.request.uri} headers: ${formatHeadersForLog(call.request.headers)}" }
     val raw = call.receiveText()
     if (raw.isBlank()) {
         call.respondText(errorJson("empty body"), ContentType.Application.Json, HttpStatusCode.BadRequest)
@@ -157,7 +212,7 @@ private suspend fun handleChat(
     var anyClaimed = false
 
     while (true) {
-        val up = pickFreeUpstream(pool, active, failed) ?: break
+        val up = pickFreeUpstream(pool, active, failed, backoff, modelName) ?: break
         anyClaimed = true
         val start = TimeSource.Monotonic.markNow()
         try {
@@ -168,7 +223,8 @@ private suspend fun handleChat(
                 continue
             }
 
-            val patched = buildBody(bodyJson, provider, up, modelConf)
+            val patched0 = buildBody(bodyJson, provider, up, modelConf)
+            val patched = applyReasoningField(patched0, provider.reasoning_field, provider.reasoning_empty_ok)
             val forwarded = if (clientWantsStream) {
                 patched
             } else {
@@ -183,13 +239,27 @@ private suspend fun handleChat(
 
             val url = provider.url.trimEnd('/') + "/chat/completions"
             val providerKey = resolveEnv(provider.key)
+            val sessionHeader = provider.session_header
+            // Клиентский одноимённый заголовок не пробрасываем: при метке
+            // значение x-opencode-session всегда вычисляем сами (LCP по истории).
+            val forwardedHeaders = headersToForward(call.request.headers)
+                .filterKeys { sessionHeader == null || !it.equals(sessionHeader, ignoreCase = true) }
+            val sessionId = sessionHeader?.let { sessions.resolve(sessionPrefixHashes(forwarded)) }
+            val outgoingHeaders = forwardedHeaders.toMutableMap().apply {
+                this["Content-Type"] = listOf("application/json")
+                if (providerKey.isNotEmpty()) this["Authorization"] = listOf("Bearer $providerKey")
+                if (sessionHeader != null && sessionId != null) this[sessionHeader] = listOf(sessionId)
+            }
+            log.info {
+                "[llm-proxy] chat model=$modelName upstream=${up.id} session=${sessionId ?: "-"} → $url headers: ${formatHeadersForLog(outgoingHeaders)}"
+            }
             var failover = false
             var responded = false
             var upstreamStatus = 0
 
             http.preparePost(url) {
                 headers {
-                    headersToForward(call.request.headers).forEach { (name, values) ->
+                    forwardedHeaders.forEach { (name, values) ->
                         appendAll(name, values)
                     }
                     // Авторизация — всегда наша (ключ провайдера из конфига);
@@ -199,32 +269,51 @@ private suspend fun handleChat(
                         set("Authorization", "Bearer $providerKey")
                     }
                     set("Content-Type", "application/json")
+                    if (sessionHeader != null && sessionId != null) {
+                        set(sessionHeader, sessionId)
+                    }
                 }
                 setBody(forwarded.toString())
             }.execute { resp ->
                 upstreamStatus = resp.status.value
-                if (upstreamStatus >= 500 || upstreamStatus == 429) {
-                    log.warn { "[llm-proxy] model=$modelName upstream=${up.id} вернул $upstreamStatus → фейловер" }
+                if (upstreamStatus >= 500 || upstreamStatus == 429 || upstreamStatus == 402) {
+                    val rest = backoff.recordFailure(up)
+                    metrics.record(modelName, up, statusClass(upstreamStatus))
+                    log.warn {
+                        "[llm-proxy] model=$modelName upstream=${up.id} вернул $upstreamStatus → фейловер" +
+                            (rest?.let { " (backoff: отдых ${it.toIsoString()})" } ?: "")
+                    }
                     failed.add(up.id)
                     failover = true
                     return@execute
                 }
+                if (upstreamStatus in 400..499) {
+                    // 4xx — JSON-тело, не стрим: читаем безопасно и отдаём клиенту как есть.
+                    val errorBody = runCatching { resp.body<String>() }.getOrDefault("")
+                    log.warn { "[llm-proxy] chat model=$modelName upstream=${up.id} вернул $upstreamStatus errorBody=${errorBody.take(500)}" }
+                    metrics.record(modelName, up, statusClass(upstreamStatus))
+                    val ct = resp.headers["Content-Type"] ?: "application/json"
+                    call.respondText(errorBody, ContentType.parse(ct), HttpStatusCode.fromValue(upstreamStatus))
+                    responded = true
+                    return@execute
+                }
                 responded = true
+                backoff.recordSuccess(up)
                 if (clientWantsStream) {
                     val ct = resp.headers["Content-Type"] ?: "text/event-stream"
                     val status = HttpStatusCode.fromValue(upstreamStatus)
+                    val thinkMode = effectiveThinkTags(up, provider)
+                    val firstByteTimeout = effectiveFirstByteTimeout(up, provider)
                     call.respondBytesWriter(ContentType.parse(ct), status) {
                         val ch = resp.body<ByteReadChannel>()
-                        val buf = ByteArray(8192)
-                        while (true) {
-                            val n = ch.readAvailable(buf)
-                            if (n == -1) break
-                            if (n > 0) {
-                                writeFully(buf, 0, n)
-                                flush()
-                            }
+                        if (thinkMode == "off") {
+                            // Флажок не выставлен — сырой байтовый passthrough + выравнивание конца потока.
+                            streamRawWithDoneContract(ch, firstByteTimeout)
+                        } else {
+                            streamSseWithThinkTags(ch, thinkMode, firstByteTimeout)
                         }
                     }
+                    metrics.record(modelName, up, "ok")
                     log.info {
                         "[llm-proxy] chat model=$modelName upstream=${up.id} provider=${provider.id} " +
                             "status=$upstreamStatus за ${start.elapsedNow().inWholeMilliseconds}ms stream=true"
@@ -232,7 +321,12 @@ private suspend fun handleChat(
                 } else {
                     val ct = resp.headers["Content-Type"] ?: "application/json"
                     val full = resp.body<String>()
-                    val out = if (ct.contains("text/event-stream")) rebuildFromChunks(full) else full
+                    val thinkMode = effectiveThinkTags(up, provider)
+                    val rebuilt = if (ct.contains("text/event-stream")) rebuildFromChunks(full) else full
+                    val out = if (thinkMode != "off") (
+                        runCatching { transformThinkMessage(json.parseToJsonElement(rebuilt).jsonObject, thinkMode) }
+                            .getOrNull() ?: rebuilt
+                    ) else rebuilt
                     val outCt = runCatching {
                         if (ct.contains("text/event-stream") &&
                             Json.parseToJsonElement(out).jsonObject["error"] != null
@@ -243,6 +337,7 @@ private suspend fun handleChat(
                         }
                     }.getOrDefault(ContentType.parse(ct))
                     call.respondText(out, outCt, HttpStatusCode.fromValue(upstreamStatus))
+                    metrics.record(modelName, up, "ok")
                     log.info {
                         "[llm-proxy] chat model=$modelName upstream=${up.id} provider=${provider.id} " +
                             "status=$upstreamStatus за ${start.elapsedNow().inWholeMilliseconds}ms stream=false"
@@ -252,11 +347,26 @@ private suspend fun handleChat(
 
             if (failover) continue
             if (responded) return
+        } catch (e: FirstByteTimeoutException) {
+            val rest = backoff.recordFailure(up)
+            metrics.record(modelName, up, "timeout")
+            log.warn {
+                "[llm-proxy] chat model=$modelName upstream=${up.id} TIMEOUT: первый байт не пришёл за ${e.timeoutMs}ms → фейловер" +
+                    (rest?.let { " (backoff: отдых ${it.toIsoString()})" } ?: "")
+            }
+            failed.add(up.id)
+            continue
         } catch (e: CancellationException) {
+            metrics.record(modelName, up, "cancelled")
             log.info { "[llm-proxy] chat model=$modelName upstream=${up.id} ОТМЕНЕНО клиентом за ${start.elapsedNow().inWholeMilliseconds}ms" }
             throw e
         } catch (e: Exception) {
-            log.error { "[llm-proxy] chat model=$modelName upstream=${up.id} ОШИБКА: ${e.message} за ${start.elapsedNow().inWholeMilliseconds}ms → фейловер" }
+            val rest = backoff.recordFailure(up)
+            metrics.record(modelName, up, "net_err")
+            log.error {
+                "[llm-proxy] chat model=$modelName upstream=${up.id} ОШИБКА: ${e::class.simpleName}: ${e.message} за ${start.elapsedNow().inWholeMilliseconds}ms → фейловер" +
+                    (rest?.let { " (backoff: отдых ${it.toIsoString()})" } ?: "")
+            }
             failed.add(up.id)
             continue
         } finally {
@@ -267,7 +377,17 @@ private suspend fun handleChat(
     if (anyClaimed) {
         call.respondText(errorJson("all upstreams failed"), ContentType.Application.Json, HttpStatusCode.ServiceUnavailable)
     } else {
-        call.respondText(errorJson("all upstreams busy"), ContentType.Application.Json, HttpStatusCode.ServiceUnavailable)
+        val retryIn = pool.map { backoff.remainingSeconds(it) }.filter { it > 0 }.minOrNull()
+        if (retryIn != null) {
+            call.response.headers.append("Retry-After", retryIn.toString())
+            call.respondText(
+                errorJson("all upstreams cooling, retry in ${retryIn}s"),
+                ContentType.Application.Json,
+                HttpStatusCode.ServiceUnavailable,
+            )
+        } else {
+            call.respondText(errorJson("all upstreams busy"), ContentType.Application.Json, HttpStatusCode.ServiceUnavailable)
+        }
     }
 }
 
@@ -287,6 +407,9 @@ private val SKIP_HEADER_NAMES = setOf(
     // Authorization управляется прокси явно (ключ провайдера), клиентский
     // не пересылается
     "authorization",
+    // Content-Type всегда наш (application/json: тело мержится как JSON),
+    // клиентский не пересылаем, чтобы не ушло двух заголовков
+    "content-type",
 )
 
 /**
@@ -302,6 +425,29 @@ internal fun headersToForward(request: Headers): Map<String, List<String>> =
         .filter { (name, _) -> name.lowercase() !in SKIP_HEADER_NAMES }
         .associate { (name, values) -> name to values }
 
+/** Заголовки, значения которых маскируются в логах (секреты клиента). */
+private val SENSITIVE_HEADER_NAMES = setOf(
+    "authorization",
+    "proxy-authorization",
+    "x-api-key",
+    "api-key",
+    "cookie",
+    "set-cookie",
+)
+
+/**
+ * Заголовки в виде строки для лога (`name=v1|v2, ...`). Значения чувствительных
+ * имён ([SENSITIVE_HEADER_NAMES]) маскируются `***`, чтобы не светить секреты.
+ */
+internal fun formatHeadersForLog(headers: Map<String, List<String>>): String =
+    headers.entries.joinToString(", ") { (name, values) ->
+        val shown = if (name.lowercase() in SENSITIVE_HEADER_NAMES) values.map { "***" } else values
+        "$name=${shown.joinToString("|")}"
+    }
+
+internal fun formatHeadersForLog(headers: Headers): String =
+    formatHeadersForLog(headers.entries().associate { (name, values) -> name to values })
+
 /**
  * Сборка тела запроса: подмена `model` на реальное имя апстрима + глубокий
  * послойный мерж `patch` в порядке provider → upstream → model.
@@ -367,6 +513,52 @@ internal fun tryClaim(up: UpstreamConf, active: Map<String, UpstreamCounter>): B
 internal fun effectiveConcurrencyLimit(up: UpstreamConf, provider: ProviderConf?): Int =
     up.max_concurrency ?: provider?.max_concurrency ?: Int.MAX_VALUE
 
+/**
+ * Эффективные think_tags апстрима: значение у апстрима, если задано; иначе у
+ * провайдера; иначе "off". Значения "true" трактуются как "split", "false" и
+ * любое неизвестное/пустое — как "off".
+ */
+internal fun effectiveThinkTags(up: UpstreamConf, provider: ProviderConf?): String {
+    val raw = up.think_tags ?: provider?.think_tags ?: "off"
+    return when (raw) {
+        "split", "strip" -> raw
+        "true" -> "split"
+        else -> "off"
+    }
+}
+
+/**
+ * Эффективный first-byte-timeout для стрим-ответа: значение у апстрима, если
+ * задано; иначе у провайдера; иначе [DEFAULT_FIRST_BYTE_TIMEOUT]. Возвращает
+ * null, если явно отключено (`Duration.ZERO` — `PT0S`): тогда стрим
+ * ждёт первого байта без лимита (в пределах общего
+ * [UPSTREAM_REQUEST_TIMEOUT_MS]).
+ */
+internal fun effectiveFirstByteTimeout(up: UpstreamConf, provider: ProviderConf?): Duration? {
+    val raw = up.first_byte_timeout ?: provider?.first_byte_timeout ?: DEFAULT_FIRST_BYTE_TIMEOUT
+    return if (raw <= Duration.ZERO) null else raw
+}
+
+/**
+ * Эффективный интервал фонового пинга апстрима в backoff-откате: значение у
+ * апстрима, если задано; иначе у провайдера; иначе [DEFAULT_PROBE_INTERVAL].
+ * Возвращает null, если явно отключено (`Duration.ZERO` — `PT0S`): тогда
+ * HealthProber этот апстрим не пингует (ждём естественного истечения бэкоффа).
+ */
+internal fun effectiveProbeInterval(up: UpstreamConf, provider: ProviderConf?): Duration? {
+    val raw = up.probe_interval ?: provider?.probe_interval ?: DEFAULT_PROBE_INTERVAL
+    return if (raw <= Duration.ZERO) null else raw
+}
+
+/**
+ * Сигнализирует, что апстрим не прислал ни одного байта тела стрим-ответа за
+ * [timeoutMs] мс. Обрабатывается как обычный сбой (фейловер, backoff,
+ * метрика `timeout`), но отделён от [CancellationException] (отмена клиентом)
+ * и от generic `Exception` (сетевые ошибки).
+ */
+class FirstByteTimeoutException(val timeoutMs: Long) :
+    RuntimeException("upstream did not send first byte within ${timeoutMs}ms")
+
 /** Освободить слот апстрима (в finally по завершении проксирования). */
 internal fun release(up: UpstreamConf, active: Map<String, UpstreamCounter>) {
     active.getValue(up.id).release()
@@ -411,17 +603,31 @@ class UpstreamCounter(private val limit: Int, initial: Int = 0) {
 
 /**
  * Выбор апстрима для попытки: первый по порядку (приоритету) апстрим из `pool`,
- * у которого свободен слот и который ещё не в `excluded` (не упал ранее).
- * Сразу занимает слот (через [tryClaim]). Если свободных нет — возвращает null.
+ * у которого свободен слот, который ещё не в `excluded` (не упал ранее) и
+ * не в backoff-откате. Сразу занимает слот (через [tryClaim]).
+ * Если свободных нет — возвращает null.
  */
-internal fun pickFreeUpstream(
+internal suspend fun pickFreeUpstream(
     pool: List<UpstreamConf>,
     active: Map<String, UpstreamCounter>,
     excluded: Set<String>,
-): UpstreamConf? =
-    pool.firstOrNull { up -> up.id !in excluded && tryClaim(up, active) }
+    backoff: BackoffRegistry,
+    modelName: String = "?",
+): UpstreamConf? {
+    for (up in pool) {
+        if (up.id in excluded) continue
+        val rest = backoff.remainingSeconds(up)
+        if (rest > 0) {
+            log.info { "[llm-proxy] model=$modelName upstream=${up.id} в backoff-откате (~${rest}c) — пропускаю" }
+            continue
+        }
+        if (tryClaim(up, active)) return up
+    }
+    return null
+}
 
 private suspend fun handleModels(call: ApplicationCall, config: Config) {
+    log.info { "[llm-proxy] models ${call.request.httpMethod.value} ${call.request.uri} headers: ${formatHeadersForLog(call.request.headers)}" }
     val created = TimeSource.Monotonic.markNow().elapsedNow().inWholeSeconds
     val data = config.models.map { m ->
         JsonObject(
@@ -469,27 +675,27 @@ internal fun rebuildFromChunks(sse: String): String {
         val data = line.removePrefix("data:").trim()
         if (data.isEmpty() || data == "[DONE]") return@forEach
         val obj = runCatching { json.parseToJsonElement(data).jsonObject }.getOrNull() ?: return@forEach
-        if (id.isEmpty()) id = obj["id"]?.jsonPrimitive?.content ?: ""
-        if (created == null) created = obj["created"]?.jsonPrimitive?.content?.toLongOrNull()
-        if (model.isEmpty()) model = obj["model"]?.jsonPrimitive?.content ?: ""
-        if (systemFingerprint == null) systemFingerprint = obj["system_fingerprint"]?.jsonPrimitive?.content
-        if (serviceTier == null) serviceTier = obj["service_tier"]?.jsonPrimitive?.content
+        if (id.isEmpty()) id = (obj["id"] as? JsonPrimitive)?.content ?: ""
+        if (created == null) created = (obj["created"] as? JsonPrimitive)?.content?.toLongOrNull()
+        if (model.isEmpty()) model = (obj["model"] as? JsonPrimitive)?.content ?: ""
+        if (systemFingerprint == null) systemFingerprint = (obj["system_fingerprint"] as? JsonPrimitive)?.content
+        if (serviceTier == null) serviceTier = (obj["service_tier"] as? JsonPrimitive)?.content
         if (provider == null) provider = obj["provider"]
         (obj["error"] as? JsonObject)?.let { error = it }
         (obj["usage"] as? JsonObject)?.let { usage = it }
-        val chArr = obj["choices"]?.jsonArray ?: return@forEach
+        val chArr = obj["choices"] as? JsonArray ?: return@forEach
         for (ch in chArr) {
-            val c = ch.jsonObject
-            val idx = c["index"]?.jsonPrimitive?.content?.toIntOrNull() ?: 0
+            val c = ch as? JsonObject ?: continue
+            val idx = (c["index"] as? JsonPrimitive)?.content?.toIntOrNull() ?: 0
             val mc = choices.getOrPut(idx) { MutableChoice() }
-            val delta = c["delta"]?.jsonObject
+            val delta = c["delta"] as? JsonObject
             if (delta != null) {
-                if (mc.role == null) mc.role = delta["role"]?.jsonPrimitive?.content
-                delta["content"]?.jsonPrimitive?.content?.takeIf { it != "null" }?.let { mc.content.append(it) }
-                delta["reasoning_content"]?.jsonPrimitive?.content?.takeIf { it != "null" }?.let { mc.reasoning.append(it) }
-                delta["tool_calls"]?.jsonArray?.forEach { tc -> (tc as? JsonObject)?.let { mc.toolCalls.add(it) } }
+                if (mc.role == null) mc.role = (delta["role"] as? JsonPrimitive)?.content
+                (delta["content"] as? JsonPrimitive)?.content?.takeIf { it != "null" }?.let { mc.content.append(it) }
+                (delta["reasoning_content"] as? JsonPrimitive)?.content?.takeIf { it != "null" }?.let { mc.reasoning.append(it) }
+                (delta["tool_calls"] as? JsonArray)?.forEach { tc -> (tc as? JsonObject)?.let { mc.toolCalls.add(it) } }
             }
-            c["finish_reason"]?.jsonPrimitive?.content?.takeIf { it.isNotEmpty() && it != "null" }?.let { mc.finishReason = it }
+            (c["finish_reason"] as? JsonPrimitive)?.content?.takeIf { it.isNotEmpty() && it != "null" }?.let { mc.finishReason = it }
             c["logprobs"]?.let { mc.logprobs = it }
         }
     }
@@ -530,6 +736,363 @@ internal fun rebuildFromChunks(sse: String): String {
     return JsonObject(root).toString()
 }
 
+/**
+ * Пересобрать полный chat.completion (обычный JSON или результат
+ * [rebuildFromChunks]): по каждому choice взять `message.content` — только если
+ * это JSON-строка (массив частей не трогаем) — и прогнать целиком через
+ * [ThinkTagSplitter] (feed + finish). Остаток возвращается в `message.content`,
+ * вырезанное — в `message.reasoning_content` (режим split; при strip не
+ * добавляем). Если `reasoning_content` уже был непустой строкой — новое
+ * дописываем в конец существующего, не теряя прежнее. Ни один choice не
+ * изменился → null (отдать исходную строку как есть).
+ */
+internal fun transformThinkMessage(obj: JsonObject, thinkMode: String): String? {
+    val choices = obj["choices"] as? JsonArray ?: return null
+    val addReasoning = thinkMode == "split"
+    var changed = false
+    val newChoices = choices.map { choiceEl ->
+        val choice = choiceEl as? JsonObject ?: return@map choiceEl
+        val message = choice["message"] as? JsonObject ?: return@map choiceEl
+        val contentStr = (message["content"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+        if (contentStr == null) return@map choiceEl
+        val splitter = ThinkTagSplitter(thinkMode)
+        val (outContent, outReasoning) = splitter.feed(contentStr)
+        val (tailContent, tailReasoning) = splitter.finish()
+        val reasoning = outReasoning + tailReasoning
+        changed = true
+        val newMessage = message.toMutableMap().apply {
+            this["content"] = JsonPrimitive(outContent + tailContent)
+            if (addReasoning && reasoning.isNotEmpty()) {
+                val existing = (this["reasoning_content"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+                this["reasoning_content"] = JsonPrimitive((existing ?: "") + reasoning)
+            }
+        }
+        JsonObject(choice.toMutableMap().apply { this["message"] = JsonObject(newMessage) })
+    }
+    if (!changed) return null
+    return JsonObject(obj.toMutableMap().apply { this["choices"] = JsonArray(newChoices) }).toString()
+}
+
+/**
+ * Достроить нативное поле рассуждений для апстримов, которые его требуют
+ * (Console Go / deepseek в thinking-режиме): если у провайдера объявлено
+ * `reasoningField`, то в каждом assistant-сообщении добавляем это поле,
+ * ЕСЛИ его там ещё нет (не только в тех, что с tool_calls — deepseek
+ * требует `reasoning_content` на КАЖДОМ ассистент-сообщении в thinking-режиме,
+ * см. «must be passed back to the API»). Текст берём из `reasoning`
+ * (строка) или из `reasoning_details` (элементы с `type == "reasoning.text"`).
+ * Существующее непустое поле НЕ перезаписываем. При полном отсутствии текста
+ * пишем пустую строку, только если `emptyOk` — апстрим требует самого
+ * НАЛИЧИЯ поля, даже пустого (так делает и сам opencode).
+ * Тело возвращается без изменений (тот же объект), если менять нечего.
+ */
+internal fun applyReasoningField(body: JsonObject, field: String?, emptyOk: Boolean): JsonObject {
+    if (field == null) return body
+    val messages = body["messages"] as? JsonArray ?: return body
+    var changed = false
+    val newMessages = messages.map { el ->
+        val msg = el as? JsonObject ?: return@map el
+        val role = (msg["role"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+        if (role != "assistant") return@map el
+        val existing = (msg[field] as? JsonPrimitive)?.takeIf { it.isString }?.content
+        if (existing != null && existing.isNotEmpty()) return@map el
+        val text = reasoningTextOf(msg)
+        if (text.isEmpty() && !emptyOk) return@map el
+        changed = true
+        JsonObject(msg.toMutableMap().apply { this[field] = JsonPrimitive(text) })
+    }
+    if (!changed) return body
+    return JsonObject(body.toMutableMap().apply { this["messages"] = JsonArray(newMessages) })
+}
+
+/**
+ * Текст рассуждений сообщения: `reasoning` (если непустая строка), иначе
+ * склейка `reasoning_details[*].text` через "\n" — только элементы, у которых
+ * `type` отсутствует или равен "reasoning.text".
+ */
+internal fun reasoningTextOf(msg: JsonObject): String {
+    val reasoning = (msg["reasoning"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+    if (reasoning != null && reasoning.isNotEmpty()) return reasoning
+    val details = msg["reasoning_details"] as? JsonArray ?: return ""
+    val parts = details.mapNotNull { el ->
+        val d = el as? JsonObject ?: return@mapNotNull null
+        val type = (d["type"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+        if (type != null && type != "reasoning.text") return@mapNotNull null
+        (d["text"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+    }
+    return parts.joinToString("\n")
+}
+
+/** Терминальный маркер SSE, который клиенты (в т.ч. Bifrost) ждут как конец потока. */
+private const val SSE_DONE_MARKER = "data: [DONE]\n\n"
+
+/** Размер скользящего окна детектора: маркер может разрезаться границей чтения. */
+private const val STREAM_SCAN_WINDOW = 128
+
+/**
+ * Есть ли в тексте `finish_reason` со значением, отличным от `null`. Экранированные
+ * вхождения (`\"finish_reason\\\":\\\"stop\\\"` внутри содержимого ответа) не считаются:
+ * смотрим только на неэкранированную кавычку.
+ */
+internal fun hasNonNullFinishReasonText(text: String): Boolean {
+    var from = 0
+    while (true) {
+        val i = text.indexOf("finish_reason", from)
+        if (i < 0) return false
+        val quote = i - 1
+        val escaped = quote >= 0 && text[quote] == '"' && quote > 0 && text[quote - 1] == '\\'
+        if (!escaped) {
+            val rest = text.substring(i + "finish_reason".length)
+                .dropWhile { it == ' ' || it == ':' || it == '"' }
+            if (!rest.startsWith("null")) return true
+        }
+        from = i + 1
+    }
+}
+
+/** Структурная проверка чанка: в `choices[*].finish_reason` есть непустая строка. */
+internal fun hasFinishReason(obj: JsonObject): Boolean =
+    (obj["choices"] as? JsonArray)?.any { el ->
+        (el as? JsonObject)?.let { choice ->
+            val fr = (choice["finish_reason"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+            !fr.isNullOrEmpty()
+        } ?: false
+    } ?: false
+
+/**
+ * Детектор контракта конца SSE для сырого passthrough-потока (`think_tags: off`).
+ * Копит скользящее окно последних байт, чтобы маркер `finish_reason`/`[DONE]`,
+ * разрезанный границей чтения, всё равно был распознан, и запоминает два факта:
+ * видели ли непустой `finish_reason` и видели ли `[DONE]`.
+ */
+internal class StreamEndDetector(private val windowSize: Int = STREAM_SCAN_WINDOW) {
+    var sawFinishReason = false
+        private set
+
+    var sawDone = false
+        private set
+
+    private var window: String = ""
+
+    fun feed(bytes: ByteArray, from: Int = 0, length: Int = bytes.size) {
+        if (length <= 0) return
+        val scan = window + bytes.decodeToString(from, from + length)
+        if (!sawDone && scan.contains("[DONE]")) sawDone = true
+        if (!sawFinishReason && hasNonNullFinishReasonText(scan)) sawFinishReason = true
+        window = if (scan.length > windowSize) scan.substring(scan.length - windowSize) else scan
+    }
+
+    /**
+     * Маркер нужен, только если апстрим закрыл поток после штатного `finish_reason`,
+     * но сам `[DONE]` не прислал. При обрыве БЕЗ `finish_reason` маркер НЕ дописываем.
+     */
+    val missingDoneMarker: Boolean get() = sawFinishReason && !sawDone
+}
+
+/**
+ * Сырой байтовый passthrough стрима (`think_tags: off`) с выравниванием контракта
+ * конца потока: байты уходят клиенту как есть, а если апстрим закрыл поток, не
+ * прислав `data: [DONE]`, но `finish_reason` в потоке был — дописываем маркер.
+ * Если задан [firstByteTimeout] (non-null), первый байт тела должен прийти
+ * за это время, иначе бросаем [FirstByteTimeoutException]; после первого
+ * байта watchdog выключается (ждём ответа вплоть до общего
+ * [UPSTREAM_REQUEST_TIMEOUT_MS]).
+ */
+internal suspend fun ByteWriteChannel.streamRawWithDoneContract(
+    source: ByteReadChannel,
+    firstByteTimeout: Duration? = null,
+) {
+    val detector = StreamEndDetector()
+    val buf = ByteArray(8192)
+    val timeoutMs = firstByteTimeout?.inWholeMilliseconds ?: 0L
+    var isFirstRead = timeoutMs > 0L
+    while (true) {
+        val n = if (isFirstRead) {
+            isFirstRead = false
+            readAvailableWithTimeout(source, buf, timeoutMs)
+        } else {
+            source.readAvailable(buf)
+        }
+        if (n == -1) break
+        if (n > 0) {
+            writeFully(buf, 0, n)
+            flush()
+            detector.feed(buf, 0, n)
+        }
+    }
+    if (detector.missingDoneMarker) {
+        emitUtf8(SSE_DONE_MARKER)
+        flush()
+    }
+}
+
+/**
+ * Построчный разбор SSE-стрима с рассечением think-тегов. Строки, не начинающиеся
+ * с `data:`, и `data: [DONE]` уходят клиенту без изменений (с `\n`). Прочие
+ * `data:`-строки парсятся и прогоняются через [transformThinkChunk]; результат
+ * записывается как `data: <json>\n\n` (событие-граница SSE), а при ошибке парса —
+ * исходная строка. Каждую строку сразу `flush()`, чтобы стрим не «залипал» в
+ * буфере. В конце потока накопленные хвосты сплиттеров сбрасываются финиш-чанком.
+ * Если задан [firstByteTimeout] (non-null), первая строка должна прийти за это
+ * время, иначе [FirstByteTimeoutException] (watchdog только на первой строке).
+ */
+internal suspend fun ByteWriteChannel.streamSseWithThinkTags(
+    source: ByteReadChannel,
+    thinkMode: String,
+    firstByteTimeout: Duration? = null,
+) {
+    val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+    val addReasoning = thinkMode == "split"
+    var sawDone = false
+    var sawFinishReason = false
+    val timeoutMs = firstByteTimeout?.inWholeMilliseconds ?: 0L
+    var isFirstRead = timeoutMs > 0L
+
+    suspend fun readNext(): String? = if (isFirstRead) {
+        isFirstRead = false
+        readLineWithTimeout(source, timeoutMs)
+    } else {
+        source.readLine(LineEnding.Lenient)
+    }
+
+    while (true) {
+        val line = readNext() ?: break
+        when {
+            line.startsWith("data:") -> {
+                val payload = line.removePrefix("data:").trim()
+                if (payload == "[DONE]") {
+                    sawDone = true
+                    emitUtf8(SSE_DONE_MARKER)
+                } else {
+                    val obj = runCatching { json.parseToJsonElement(payload).jsonObject }.getOrNull()
+                    if (obj != null && hasFinishReason(obj)) sawFinishReason = true
+                    val out = obj?.let { transformThinkChunk(it, splitters, thinkMode, addReasoning) }
+                    if (out == null) emitUtf8("$line\n\n") else emitUtf8("data: $out\n\n")
+                }
+            }
+            else -> emitUtf8("$line\n")
+        }
+        flush()
+    }
+    if (thinkMode == "split" || thinkMode == "strip") {
+        splitters.forEach { (idx, sp) ->
+            val (tail, reasoning) = sp.finish()
+            val hasContent = tail.isNotEmpty()
+            val hasReasoning = addReasoning && reasoning.isNotEmpty()
+            if (!hasContent && !hasReasoning) return@forEach
+            val delta = mutableMapOf<String, JsonElement>()
+            if (hasContent) delta["content"] = JsonPrimitive(tail)
+            if (hasReasoning) delta["reasoning_content"] = JsonPrimitive(reasoning)
+            val chunk = JsonObject(
+                mutableMapOf(
+                    "choices" to JsonArray(
+                        listOf(
+                            JsonObject(
+                                mutableMapOf(
+                                    "index" to JsonPrimitive(idx),
+                                    "delta" to JsonObject(delta),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            )
+            emitUtf8("data: $chunk\n\n")
+            flush()
+        }
+    }
+    // После сброса хвостов дописываем маркер, только если апстрим его не прислал,
+    // а `finish_reason` в потоке был (при обрыве без него маркер НЕ дописываем).
+    if (sawFinishReason && !sawDone) {
+        emitUtf8(SSE_DONE_MARKER)
+        flush()
+    }
+}
+
+/**
+ * Прочитать из [source] в [buf] с жёстким лимитом [timeoutMs]: если за это
+ * время ни одного байта не пришло, бросить [FirstByteTimeoutException].
+ * `select` отменяет «проигравшую» ветку; при таймауте явно отменяем и
+ * дожидаемся чтение (`cancelAndJoin`), чтобы соединение с апстримом
+ * корректно закрылось. Сентинел [Int.MIN_VALUE] невозможен как результат
+ * [ByteReadChannel.readAvailable] (это `-1` для EOF или `>= 0` для байт).
+ */
+internal suspend fun readAvailableWithTimeout(source: ByteReadChannel, buf: ByteArray, timeoutMs: Long): Int =
+    coroutineScope {
+        val readJob = async { source.readAvailable(buf) }
+        val result = select<Int> {
+            readJob.onAwait { it }
+            onTimeout(timeoutMs) { Int.MIN_VALUE }
+        }
+        if (result == Int.MIN_VALUE) {
+            readJob.cancelAndJoin()
+            throw FirstByteTimeoutException(timeoutMs)
+        }
+        result
+    }
+
+/**
+ * Прочитать строку из [source] с лимитом [timeoutMs]: если за это время ни
+ * одной строки/байта не пришло, бросить [FirstByteTimeoutException].
+ * [ByteReadChannel.readLine] возвращает `null` и при EOF, и (через `onTimeout`)
+ * при таймауте; различаем по состоянию [readJob]: если ветка чтения не
+ * завершилась к моменту возврата из `select` — таймаут (select отменил её).
+ */
+internal suspend fun readLineWithTimeout(source: ByteReadChannel, timeoutMs: Long): String? =
+    coroutineScope {
+        val readJob = async { source.readLine(LineEnding.Lenient) }
+        val result = select<String?> {
+            readJob.onAwait { it }
+            onTimeout(timeoutMs) { null }
+        }
+        if (result == null && !readJob.isCompleted) {
+            readJob.cancelAndJoin()
+            throw FirstByteTimeoutException(timeoutMs)
+        }
+        result
+    }
+
+/**
+ * Пересобрать SSE-чанк: по каждому choice (ключ `index`, дефолт 0) взять
+ * `delta.content` (только если это JSON-строка; массив частей не трогаем) и
+ * прогнать через [ThinkTagSplitter] для этого index. Остаток возвращается в
+ * `delta.content` (поле убирается, если пустое); вырезанное — в
+ * `delta.reasoning_content` (только режим split, при strip не добавляем).
+ * Чанк без `choices` или без строкового `delta.content` не меняется —
+ * возвращается null (отдать исходную строку как есть).
+ */
+internal fun transformThinkChunk(
+    obj: JsonObject,
+    splitters: MutableMap<Int, ThinkTagSplitter>,
+    thinkMode: String,
+    addReasoning: Boolean,
+): String? {
+    val choices = obj["choices"] as? JsonArray ?: return null
+    var changed = false
+    val newChoices = choices.map { choiceEl ->
+        val choice = choiceEl as? JsonObject ?: return@map choiceEl
+        val delta = choice["delta"] as? JsonObject
+        val contentStr = (delta?.get("content") as? JsonPrimitive)?.takeIf { it.isString }?.content
+        if (contentStr == null) return@map choiceEl
+        val idx = (choice["index"] as? JsonPrimitive)?.content?.toIntOrNull() ?: 0
+        val splitter = splitters.getOrPut(idx) { ThinkTagSplitter(thinkMode) }
+        val (newContent, reasoning) = splitter.feed(contentStr)
+        changed = true
+        val newDelta = delta.toMutableMap()
+        if (newContent.isEmpty()) newDelta.remove("content") else newDelta["content"] = JsonPrimitive(newContent)
+        if (addReasoning && reasoning.isNotEmpty()) newDelta["reasoning_content"] = JsonPrimitive(reasoning)
+        JsonObject(choice.toMutableMap().apply { this["delta"] = JsonObject(newDelta) })
+    }
+    if (!changed) return null
+    return JsonObject(obj.toMutableMap().apply { this["choices"] = JsonArray(newChoices) }).toString()
+}
+
+/** Записать строку как UTF-8 байты (KMP-безопасно, без java.io). */
+private suspend fun ByteWriteChannel.emitUtf8(text: String) {
+    val bytes = text.encodeToByteArray()
+    writeFully(bytes, 0, bytes.size)
+}
+
 @Serializable
 data class ProviderConf(
     val id: String,
@@ -537,6 +1100,13 @@ data class ProviderConf(
     val key: String = "",
     val max_concurrency: Int? = null,
     val patch: JsonObject? = null,
+    val session_header: String? = null,
+    val think_tags: String? = null,
+    val reasoning_field: String? = null,
+    val reasoning_empty_ok: Boolean = false,
+    val backoff: Duration? = null,
+    val first_byte_timeout: Duration? = null,
+    val probe_interval: Duration? = null,
 )
 
 data class UpstreamConf(
@@ -545,6 +1115,10 @@ data class UpstreamConf(
     val model: String,
     val max_concurrency: Int? = null,
     val patch: JsonObject? = null,
+    val think_tags: String? = null,
+    val backoff: Duration? = null,
+    val first_byte_timeout: Duration? = null,
+    val probe_interval: Duration? = null,
 )
 
 data class ModelConf(
@@ -598,6 +1172,13 @@ internal fun parseConfig(root: YamlElement): Config {
             key = m.strOrNull("key") ?: "",
             max_concurrency = m.strOrNull("max_concurrency")?.toIntOrNull(),
             patch = m.yamlMapOrNull("patch")?.let { yamlToJson(it) as JsonObject },
+            session_header = m.strOrNull("session_header"),
+            think_tags = m.strOrNull("think_tags"),
+            reasoning_field = m.strOrNull("reasoning_field"),
+            reasoning_empty_ok = m.strOrNull("reasoning_empty_ok")?.toBooleanStrictOrNull() ?: false,
+            backoff = m.durationOrNull("backoff"),
+            first_byte_timeout = m.durationOrNull("first_byte_timeout"),
+            probe_interval = m.durationOrNull("probe_interval"),
         )
     }
 
@@ -609,6 +1190,10 @@ internal fun parseConfig(root: YamlElement): Config {
             model = m.str("model"),
             max_concurrency = m.strOrNull("max_concurrency")?.toIntOrNull(),
             patch = m.yamlMapOrNull("patch")?.let { yamlToJson(it) as JsonObject },
+            think_tags = m.strOrNull("think_tags"),
+            backoff = m.durationOrNull("backoff"),
+            first_byte_timeout = m.durationOrNull("first_byte_timeout"),
+            probe_interval = m.durationOrNull("probe_interval"),
         )
     }
 
@@ -634,5 +1219,43 @@ internal fun Map<String, YamlElement>.str(key: String): String =
 internal fun Map<String, YamlElement>.strOrNull(key: String): String? =
     (this[key] as? YamlLiteral)?.content
 
+/**
+ * ISO-8601-длительность (PT30M, P1D, PT1H15M…) с расширением для годов/месяцев,
+ * которые kotlin.time не принимает (у них нет фиксированной длины):
+ * `PnY` → n×365d, `PnM` → n×30d (приближение, см. CONFIG.md).
+ * Некорректное значение — warn + null.
+ */
+internal fun Map<String, YamlElement>.durationOrNull(key: String): Duration? =
+    strOrNull(key)?.let { raw ->
+        runCatching { parseIsoDuration(raw) }.getOrElse {
+            log.warn { "[llm-proxy] config: поле '$key' — некорректная ISO-8601-длительность '$raw', проигнорировано" }
+            null
+        }
+    }
+
+/**
+ * ISO-8601-длительность для конфига: как [Duration.parse], плюс годы/месяцы
+ * (`P1M`, `P2Y`, `P1Y3M`) — приближённо 1 год = 365d, 1 месяц = 30d.
+ * (kotlin.time [Duration.parse] принимает только D/W/H/M(ин)/S.)
+ */
+internal fun parseIsoDuration(raw: String): Duration {
+    val m = Regex(
+        "^P" +
+            "(?:(\\d+)Y)?" +
+            "(?:(\\d+)M)?" +
+            "(?:(\\d+)W)?" +
+            "(?:(\\d+)D)?" +
+            "(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?",
+        RegexOption.IGNORE_CASE,
+    ).matchEntire(raw.trim()) ?: error("не ISO-8601-длительность: $raw")
+    if ((1..7).all { m.groupValues[it].isEmpty() }) error("не ISO-8601-длительность: $raw")
+    fun g(i: Int): Long = m.groupValues[i].toLongOrNull() ?: 0L
+    val days = g(1) * 365 + g(2) * 30 + g(3) * 7 + g(4)
+    val hours = g(5)
+    val minutes = g(6)
+    val seconds = g(7)
+    return days.days + hours.hours + minutes.minutes + seconds.seconds
+}
+
 internal fun Map<String, YamlElement>.yamlMapOrNull(key: String): YamlMap? =
     this[key] as? YamlMap

src/commonMain/kotlin/pw/binom/llmproxy/Metrics.kt

@@ -0,0 +1,130 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Pull-метрики для Prometheus (формат экспозиции `text/plain; version=0.0.4`),
+ * отдаются на `GET /metrics`.
+ *
+ * Метрики (всё в памяти, сброс при рестарте):
+ * - `llm_proxy_requests_total{model,upstream,provider,result}` — счётчик
+ *   chat-запросов; `result`: `ok | 4xx | 429 | 402 | 5xx | net_err | timeout | cancelled`;
+ * - `llm_proxy_probe_pings_total{upstream,provider,result}` — счётчик фоновых
+ *   пингов апстримов в backoff-откате (HealthProber); `result`: `ok | fail`;
+ * - `llm_proxy_upstream_inflight{upstream,provider}` — сейчас в работе (слоты);
+ * - `llm_proxy_upstream_fail_streak{upstream,provider}` — текущая серия сбоев
+ *   (счётчик backoff);
+ * - `llm_proxy_upstream_cooling_seconds{upstream,provider}` — сколько секунд
+ *   апстрим ещё в backoff-откате (0 = жив).
+ */
+class MetricsRegistry {
+    private val lock = Mutex()
+    private val requests = HashMap<RequestKey, Long>()
+    private val probes = HashMap<ProbeKey, Long>()
+
+    private data class RequestKey(
+        val model: String,
+        val upstream: String,
+        val provider: String,
+        val result: String,
+    )
+
+    private data class ProbeKey(
+        val upstream: String,
+        val provider: String,
+        val result: String,
+    )
+
+    /** Учёт chat-запроса по исходу (значения `result` — в описании класса). */
+    suspend fun record(model: String, up: UpstreamConf, result: String) {
+        lock.withLock {
+            val key = RequestKey(model, up.id, up.provider, result)
+            requests[key] = (requests[key] ?: 0L) + 1
+        }
+    }
+
+    /** Учёт пинга апстрима в backoff-откате (result: `ok`/`fail`). */
+    suspend fun recordProbe(up: UpstreamConf, result: String) {
+        lock.withLock {
+            val key = ProbeKey(up.id, up.provider, result)
+            probes[key] = (probes[key] ?: 0L) + 1
+        }
+    }
+
+    /** Текстовая выгрузка в формате Prometheus на текущий момент. */
+    suspend fun render(
+        config: Config,
+        active: Map<String, UpstreamCounter>,
+        backoff: BackoffRegistry,
+    ): String {
+        val sb = StringBuilder()
+        sb.append("# HELP llm_proxy_requests_total Chat-запросы llm-proxy по исходу\n")
+        sb.append("# TYPE llm_proxy_requests_total counter\n")
+        lock.withLock {
+            requests.entries
+                .sortedWith(compareBy({ it.key.model }, { it.key.upstream }, { it.key.provider }, { it.key.result }))
+                .forEach { (k, n) ->
+                    sb.append(
+                        "llm_proxy_requests_total{model=\"" + esc(k.model) +
+                            "\",upstream=\"" + esc(k.upstream) +
+                            "\",provider=\"" + esc(k.provider) +
+                            "\",result=\"" + esc(k.result) + "\"} $n\n",
+                    )
+                }
+        }
+        sb.append("# HELP llm_proxy_probe_pings_total Фоновые пинги апстримов в backoff-откате\n")
+        sb.append("# TYPE llm_proxy_probe_pings_total counter\n")
+        lock.withLock {
+            probes.entries
+                .sortedWith(compareBy({ it.key.upstream }, { it.key.provider }, { it.key.result }))
+                .forEach { (k, n) ->
+                    sb.append(
+                        "llm_proxy_probe_pings_total{upstream=\"" + esc(k.upstream) +
+                            "\",provider=\"" + esc(k.provider) +
+                            "\",result=\"" + esc(k.result) + "\"} $n\n",
+                    )
+                }
+        }
+        sb.append("# HELP llm_proxy_upstream_inflight Занято слотов апстрима сейчас\n")
+        sb.append("# TYPE llm_proxy_upstream_inflight gauge\n")
+        for (up in config.upstreams) {
+            val n = active[up.id]?.current ?: 0
+            sb.append(
+                "llm_proxy_upstream_inflight{upstream=\"" + esc(up.id) +
+                    "\",provider=\"" + esc(up.provider) + "\"} $n\n",
+            )
+        }
+        sb.append("# HELP llm_proxy_upstream_fail_streak Серия сбоев апстрима подряд (счётчик backoff)\n")
+        sb.append("# TYPE llm_proxy_upstream_fail_streak gauge\n")
+        for (up in config.upstreams) {
+            sb.append(
+                "llm_proxy_upstream_fail_streak{upstream=\"" + esc(up.id) +
+                    "\",provider=\"" + esc(up.provider) + "\"} " +
+                backoff.failStreakOf(up) + "\n",
+            )
+        }
+        sb.append("# HELP llm_proxy_upstream_cooling_seconds Секунд до выхода апстрима из backoff-отката (0 = не в откате)\n")
+        sb.append("# TYPE llm_proxy_upstream_cooling_seconds gauge\n")
+        for (up in config.upstreams) {
+            sb.append(
+                "llm_proxy_upstream_cooling_seconds{upstream=\"" + esc(up.id) +
+                    "\",provider=\"" + esc(up.provider) + "\"} " +
+                backoff.remainingSeconds(up) + "\n",
+            )
+        }
+        return sb.toString()
+    }
+
+    private fun esc(s: String): String =
+        s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n")
+}
+
+/** HTTP-статус апстрима → класс исхода для метрик. */
+internal fun statusClass(status: Int): String = when {
+    status in 200..399 -> "ok"
+    status == 429 -> "429"
+    status == 402 -> "402"
+    status in 400..499 -> "4xx"
+    else -> "5xx"
+}

src/commonMain/kotlin/pw/binom/llmproxy/Session.kt

@@ -0,0 +1,206 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.datetime.Clock
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+/**
+ * SHA-256, чистая реализация на commonMain (без внешних зависимостей —
+ * KMP-зеркало их не отдаёт). Нужен для стабильного хэша префиксов истории.
+ */
+internal object Sha256 {
+    private val K = intArrayOf(
+        0x428a2f98, 0x71374491, 0xb5c0fbcf.toInt(), 0xe9b5dba5.toInt(), 0x3956c25b, 0x59f111f1, 0x923f82a4.toInt(), 0xab1c5ed5.toInt(),
+        0xd807aa98.toInt(), 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe.toInt(), 0x9bdc06a7.toInt(), 0xc19bf174.toInt(),
+        0xe49b69c1.toInt(), 0xefbe4786.toInt(), 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152.toInt(), 0xa831c66d.toInt(), 0xb00327c8.toInt(), 0xbf597fc7.toInt(), 0xc6e00bf3.toInt(), 0xd5a79147.toInt(), 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e.toInt(), 0x92722c85.toInt(),
+        0xa2bfe8a1.toInt(), 0xa81a664b.toInt(), 0xc24b8b70.toInt(), 0xc76c51a3.toInt(), 0xd192e819.toInt(), 0xd6990624.toInt(), 0xf40e3585.toInt(), 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814.toInt(), 0x8cc70208.toInt(), 0x90befffa.toInt(), 0xa4506ceb.toInt(), 0xbef9a3f7.toInt(), 0xc67178f2.toInt(),
+    )
+
+    private fun rotr(x: Int, n: Int): Int = (x ushr n) or (x shl (32 - n))
+
+    private fun pad(input: ByteArray): ByteArray {
+        val total = ((input.size + 9 + 63) / 64) * 64
+        val out = ByteArray(total)
+        input.copyInto(out)
+        out[input.size] = 0x80.toByte()
+        val bits = input.size.toLong() * 8
+        for (k in 0 until 8) {
+            out[total - 1 - k] = (bits ushr (8 * k)).toByte()
+        }
+        return out
+    }
+
+    fun hash(input: ByteArray): ByteArray {
+        val msg = pad(input)
+        val h = intArrayOf(
+            0x6a09e667, 0xbb67ae85.toInt(), 0x3c6ef372, 0xa54ff53a.toInt(),
+            0x510e527f, 0x9b05688c.toInt(), 0x1f83d9ab, 0x5be0cd19,
+        )
+        val w = IntArray(64)
+        var i = 0
+        while (i < msg.size) {
+            for (j in 0 until 16) {
+                w[j] = ((msg[i + j * 4].toInt() and 0xff) shl 24) or
+                    ((msg[i + j * 4 + 1].toInt() and 0xff) shl 16) or
+                    ((msg[i + j * 4 + 2].toInt() and 0xff) shl 8) or
+                    (msg[i + j * 4 + 3].toInt() and 0xff)
+            }
+            for (j in 16 until 64) {
+                val s0 = rotr(w[j - 15], 7) xor rotr(w[j - 15], 18) xor (w[j - 15] ushr 3)
+                val s1 = rotr(w[j - 2], 17) xor rotr(w[j - 2], 19) xor (w[j - 2] ushr 10)
+                w[j] = w[j - 16] + s0 + w[j - 7] + s1
+            }
+            var a = h[0]; var b = h[1]; var c = h[2]; var d = h[3]
+            var e = h[4]; var f = h[5]; var g = h[6]; var hh = h[7]
+            for (j in 0 until 64) {
+                val s1 = rotr(e, 6) xor rotr(e, 11) xor rotr(e, 25)
+                val ch = (e and f) xor (e.inv() and g)
+                val t1 = hh + s1 + ch + K[j] + w[j]
+                val s0 = rotr(a, 2) xor rotr(a, 13) xor rotr(a, 22)
+                val maj = (a and b) xor (a and c) xor (b and c)
+                val t2 = s0 + maj
+                hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2
+            }
+            h[0] += a; h[1] += b; h[2] += c; h[3] += d
+            h[4] += e; h[5] += f; h[6] += g; h[7] += hh
+            i += 64
+        }
+        val out = ByteArray(32)
+        for (j in 0 until 8) {
+            out[j * 4] = (h[j] ushr 24).toByte()
+            out[j * 4 + 1] = (h[j] ushr 16).toByte()
+            out[j * 4 + 2] = (h[j] ushr 8).toByte()
+            out[j * 4 + 3] = h[j].toByte()
+        }
+        return out
+    }
+}
+
+private const val HEX = "0123456789abcdef"
+
+/** SHA-256 строки (UTF-8) в нижнем hex. */
+internal fun sha256Hex(text: String): String {
+    val bytes = Sha256.hash(text.encodeToByteArray())
+    val sb = StringBuilder(bytes.size * 2)
+    for (b in bytes) {
+        val v = b.toInt() and 0xff
+        sb.append(HEX[v ushr 4]).append(HEX[v and 0xf])
+    }
+    return sb.toString()
+}
+
+/**
+ * Инкрементальные префикс-хэши истории: H_i = sha256(H_{i-1} + "\u0000" + msg_i).
+ *
+ * Цепочка начинается с первого `user`-сообщения: system-промпт обычно
+ * идентичен у всех сессий одного клиента и как признак сессии бесполезен
+ * (иначе LCP склеивает все сессии на общем префиксе `[system]`).
+ * Если `messages` нет/пусто — fallback на хэш всего тела.
+ */
+internal fun sessionPrefixHashes(body: JsonObject): List<String> {
+    val messages = body["messages"] as? JsonArray
+    if (messages == null || messages.isEmpty()) {
+        return listOf(sha256Hex(body.toString()))
+    }
+
+    fun roleAt(i: Int): String? =
+        ((messages[i] as? JsonObject)?.get("role") as? JsonPrimitive)?.content
+
+    var start = messages.indices.firstOrNull { roleAt(it) == "user" }
+        ?: messages.indices.firstOrNull { roleAt(it) != "system" }
+        ?: 0
+
+    val res = ArrayList<String>(messages.size - start)
+    var prev = ""
+    for (i in start until messages.size) {
+        prev = sha256Hex(prev + "\u0000" + messages[i].toString())
+        res.add(prev)
+    }
+    return res
+}
+
+/**
+ * Реестр сессий: id сессии определяется наибольшим общим префиксом (LCP)
+ * присланной истории. Для префиксов, которые уже встречались, возвращается
+ * id исходной сессии; иначе создаётся новая (id = хэш всей истории).
+ *
+ * Таблица ограничена по размеру (LRU) и времени жизни (TTL). Доступ под
+ * Mutex: параллельные запросы одной сессии не должны гонять состояние.
+ */
+class SessionRegistry(
+    private val maxSessions: Int = 1000,
+    private val ttlMillis: Long = 6 * 60 * 60 * 1000L,
+) {
+    private class Entry(val prefixes: MutableSet<String>) {
+        var lastAccess: Long = 0
+    }
+
+    private val mutex = Mutex()
+    private val prefixToSession = mutableMapOf<String, String>()
+
+    /** В порядке доступа: голова — самая давняя, хвост — свежая. */
+    private val sessions = LinkedHashMap<String, Entry>()
+
+    suspend fun resolve(prefixHashes: List<String>): String? =
+        mutex.withLock { resolveLocked(prefixHashes, Clock.System.now().toEpochMilliseconds()) }
+
+    /** Синхронная (без блокировки) версия — для тестов и вызовов под mutex. */
+    internal fun resolveLocked(prefixHashes: List<String>, now: Long): String? {
+        if (prefixHashes.isEmpty()) return null
+        evictExpired(now)
+
+        var found: String? = null
+        for (i in prefixHashes.indices.reversed()) {
+            val s = prefixToSession[prefixHashes[i]]
+            if (s != null) {
+                found = s
+                break
+            }
+        }
+        val id = found ?: prefixHashes.last()
+
+        val entry = sessions.remove(id) ?: Entry(mutableSetOf())
+        for (h in prefixHashes) {
+            val prev = prefixToSession.put(h, id)
+            if (prev != null && prev != id) {
+                sessions[prev]?.prefixes?.remove(h)
+            }
+            entry.prefixes.add(h)
+        }
+        entry.lastAccess = now
+        sessions[id] = entry
+        evictOverflow()
+        return id
+    }
+
+    private fun drop(sessionId: String, entry: Entry) {
+        entry.prefixes.forEach { h -> if (prefixToSession[h] == sessionId) prefixToSession.remove(h) }
+    }
+
+    private fun evictExpired(now: Long) {
+        val it = sessions.entries.iterator()
+        while (it.hasNext()) {
+            val e = it.next()
+            if (now - e.value.lastAccess <= ttlMillis) break
+            drop(e.key, e.value)
+            it.remove()
+        }
+    }
+
+    private fun evictOverflow() {
+        val it = sessions.entries.iterator()
+        while (sessions.size > maxSessions && it.hasNext()) {
+            val e = it.next()
+            drop(e.key, e.value)
+            it.remove()
+        }
+    }
+}

src/commonMain/kotlin/pw/binom/llmproxy/ThinkTagSplitter.kt

@@ -0,0 +1,96 @@
+package pw.binom.llmproxy
+
+/**
+ * Автомат рассечения кусков стрима по think-тегам (строго lowercase). Чистая логика: без Ktor, без IO, без побочных
+ * эффектов — по одному экземпляру на choice/index.
+ *
+ * - `off` — passthrough: всё, включая теги, уходит в content;
+ * - `split` — текст внутри think-блока → reasoning,
+ *   остальное → content; несколько блоков в одном ответе обрабатываются все;
+ * - `strip` — как `split`, но рассуждения выбрасываются (reasoning всегда "").
+ *
+ * Тег может прийти разрезанным между кусками: хвост, который является
+ * префиксом ожидаемого тега: вне блока — <think>, внутри блока — </think>.
+ * Такой хвост не отдаём, держим до следующего `feed`. Если
+ * кусок показал, что хвост не тег, — отдаём его как обычный текст.
+ * Незакрытый think-блок в конце: всё после него (и накопленный хвост) — reasoning,
+ * сбрасывается в `finish`. Незнакомый режим ведёт себя как `off`.
+ */
+class ThinkTagSplitter(private val mode: String) {
+
+    private val active: Boolean = mode == "split" || mode == "strip"
+
+    private var inThink = false
+    private var pending = ""
+
+    fun feed(text: String): Pair<String, String> {
+        if (!active) return text to ""
+        val step = process(pending + text)
+        pending = step.pending
+        inThink = step.inThink
+        return step.content to if (mode == "strip") "" else step.reasoning
+    }
+
+    fun finish(): Pair<String, String> {
+        if (!active) return "" to ""
+        val tail = pending
+        val wasInThink = inThink
+        pending = ""
+        inThink = false
+        if (wasInThink) {
+            return "" to if (mode == "strip") "" else tail
+        }
+        return tail to ""
+    }
+
+    private class Step(
+        val content: String,
+        val reasoning: String,
+        val pending: String,
+        val inThink: Boolean,
+    )
+
+    private fun process(s: String): Step {
+        val content = StringBuilder()
+        val reasoning = StringBuilder()
+        var i = 0
+        var think = inThink
+        var hold = ""
+        while (i < s.length) {
+            val tag = if (think) CLOSE else OPEN
+            val idx = s.indexOf(tag, i)
+            if (idx < 0) {
+                val keep = holdableSuffix(s.substring(i), tag)
+                if (think) {
+                    reasoning.append(s, i, s.length - keep)
+                } else {
+                    content.append(s, i, s.length - keep)
+                }
+                hold = s.substring(s.length - keep)
+                break
+            }
+            if (think) {
+                reasoning.append(s, i, idx)
+            } else {
+                content.append(s, i, idx)
+            }
+            think = !think
+            i = idx + tag.length
+        }
+        return Step(content.toString(), reasoning.toString(), hold, think)
+    }
+
+    /** Максимальный суффикс хвоста, который является префиксом тега (0..tag.length-1). */
+    private fun holdableSuffix(tail: String, tag: String): Int {
+        var k = minOf(tag.length - 1, tail.length)
+        while (k > 0 && !tail.endsWith(tag.substring(0, k))) {
+            k--
+        }
+        return k
+    }
+
+    private companion object {
+        const val OPEN = "<think>"
+        const val CLOSE = "</think>"
+    }
+}

src/commonMain/kotlin/pw/binom/llmproxy/Timeouts.kt

@@ -1,4 +1,26 @@
 package pw.binom.llmproxy
 
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
 /** Предел времени на весь запрос к апстриму, мс: от отправки до приёма всего ответа (включая стриминг). */
 const val UPSTREAM_REQUEST_TIMEOUT_MS: Long = 5 * 60_000L
+
+/**
+ * Default «watchdog» на первый байт тела стрим-ответа: если апстрим не прислал
+ * ни одного байта за это время, прокси считает это сбоем апстрима и
+ * фейловерит (освобождает слот конкурентности, считает ошибку в backoff и
+ * идёт к следующему апстриму модели). Применяется ТОЛЬКО к stream=true
+ * запросам; для non-stream работает общий [UPSTREAM_REQUEST_TIMEOUT_MS].
+ * Отключается явным `first_byte_timeout: PT0S` на апстриме или провайдере.
+ */
+val DEFAULT_FIRST_BYTE_TIMEOUT: Duration = 30.seconds
+
+/**
+ * Default интервал фоновой проверки («пинга») апстрима, который сейчас в
+ * backoff-откате: пока апстрим молчит, HealthProber шлёт ему минимальный
+ * запрос (2+2=?, max_tokens=4) каждые [DEFAULT_PROBE_INTERVAL], и как только
+ * он отвечает — снимает его с отката раньше, чем истечёт интервал бэкоффа.
+ * Отключается явным `probe_interval: PT0S` на апстриме или провайдере.
+ */
+val DEFAULT_PROBE_INTERVAL: Duration = 1.seconds

src/commonTest/kotlin/pw/binom/llmproxy/BackoffTest.kt

@@ -0,0 +1,131 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.test.runTest
+import kotlinx.datetime.Instant
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFails
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+
+class BackoffTest {
+
+    private val t0 = Instant.fromEpochSeconds(1_700_000_000)
+
+    @Test
+    fun intervalsDoubleUntilCap() = runTest {
+        val g = BackoffGuard(cap = 30.seconds)
+        val seq = (1..7).map { g.recordFailure(t0) }
+        assertEquals(
+            listOf(1.seconds, 2.seconds, 4.seconds, 8.seconds, 16.seconds, 30.seconds, 30.seconds),
+            seq,
+        )
+    }
+
+    @Test
+    fun successResetsCounter() = runTest {
+        val g = BackoffGuard(cap = 30.seconds)
+        g.recordFailure(t0)
+        g.recordFailure(t0)
+        g.recordSuccess()
+        assertEquals(1.seconds, g.recordFailure(t0))
+        assertFalse(g.isCoolingAt(t0 + 1.days))
+    }
+
+    @Test
+    fun coolingWindow() = runTest {
+        val g = BackoffGuard(cap = 30.seconds)
+        g.recordFailure(t0) // отдых 1s
+        assertTrue(g.isCoolingAt(t0 + 500.milliseconds))
+        assertFalse(g.isCoolingAt(t0 + 1.seconds))
+        assertEquals(500.milliseconds, g.remainingAt(t0 + 500.milliseconds))
+    }
+
+    @Test
+    fun iso8601CapParsing() {
+        assertEquals(30.minutes, Duration.parse("PT30M"))
+        assertEquals(1.days, Duration.parse("P1D"))
+        assertEquals(90.seconds, Duration.parse("PT1M30S"))
+    }
+
+    @Test
+    fun configDurationParsingWithYearsAndMonths() {
+        // kotlin.time не принимает Y/M — конфиг-парсер расширяет: 1Y≈365d, 1M≈30d
+        assertEquals(30.days, parseIsoDuration("P1M"))
+        assertEquals(365.days, parseIsoDuration("P1Y"))
+        assertEquals(455.days, parseIsoDuration("P1Y3M"))
+        assertEquals(7.days, parseIsoDuration("P1W"))
+        assertEquals(2.days + 3.hours + 15.minutes, parseIsoDuration("P2DT3H15M"))
+        // базовый ISO-8601 без Y/M — как kotlin.time
+        assertEquals(30.minutes, parseIsoDuration("PT30M"))
+    }
+
+    @Test
+    fun configDurationParsingRejectsGarbage() {
+        assertFails { parseIsoDuration("PT30") }
+        assertFails { parseIsoDuration("1d") }
+        assertFails { parseIsoDuration("P") }
+        assertFails { parseIsoDuration("") }
+    }
+
+    @Test
+    fun providerScopeSharedBetweenItsModels() = runTest {
+        val p = ProviderConf(id = "p", url = "https://p", backoff = 5.minutes)
+        val a = UpstreamConf(id = "a", provider = "p", model = "m1")
+        val b = UpstreamConf(id = "b", provider = "p", model = "m2")
+        val reg = BackoffRegistry(mapOf("p" to p), mapOf("a" to a, "b" to b))
+
+        assertEquals(1.seconds, reg.recordFailure(a))
+
+        // общая скоуп-переменная провайдера: сбой на a охладил и b
+        assertTrue(reg.isCooling(a))
+        assertTrue(reg.isCooling(b))
+    }
+
+    @Test
+    fun upstreamBackoffOverridesProvider() = runTest {
+        val p = ProviderConf(id = "p", url = "https://p", backoff = 5.minutes)
+        val a = UpstreamConf(id = "a", provider = "p", model = "m1")
+        val b = UpstreamConf(id = "b", provider = "p", model = "m2", backoff = 30.seconds)
+        val reg = BackoffRegistry(mapOf("p" to p), mapOf("a" to a, "b" to b))
+
+        // своё backoff у b: cap 30s (не 5m провайдера): 1s, 2s, 4s, 8s, 16s, 30s (потолок)
+        val seq = (1..6).map { reg.recordFailure(b) }
+        assertEquals(listOf(1.seconds, 2.seconds, 4.seconds, 8.seconds, 16.seconds, 30.seconds), seq)
+        // скоупы независимы: сбои b не охлаждают a (провайдерский скоуп)
+        assertFalse(reg.isCooling(a))
+        assertTrue(reg.isCooling(b))
+    }
+
+    @Test
+    fun providerFailureDoesNotCoolUpstreamWithOwnBackoff() = runTest {
+        val p = ProviderConf(id = "p", url = "https://p", backoff = 5.minutes)
+        val a = UpstreamConf(id = "a", provider = "p", model = "m1")
+        val b = UpstreamConf(id = "b", provider = "p", model = "m2", backoff = 30.minutes)
+        val reg = BackoffRegistry(mapOf("p" to p), mapOf("a" to a, "b" to b))
+
+        // провайдерский скоуп заведён сбоем на a:
+        reg.recordFailure(a)
+        assertTrue(reg.isCooling(a))
+        // b живёт своим (provider-scope на него не действует):
+        assertFalse(reg.isCooling(b))
+    }
+
+    @Test
+    fun noBackoffConfiguredMeansNoCooling() = runTest {
+        val p = ProviderConf(id = "p", url = "https://p")
+        val a = UpstreamConf(id = "a", provider = "p", model = "m1")
+        val reg = BackoffRegistry(mapOf("p" to p), mapOf("a" to a))
+
+        assertNull(reg.recordFailure(a))
+        assertFalse(reg.isCooling(a))
+        assertEquals(0L, reg.remainingSeconds(a))
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ConfigLogicTest.kt

@@ -4,7 +4,9 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.seconds
 import io.ktor.http.headersOf
+import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.jsonArray
@@ -14,6 +16,8 @@ import net.mamoe.yamlkt.Yaml
 
 class ConfigLogicTest {
 
+    private val noBackoff = BackoffRegistry(emptyMap(), emptyMap())
+
     @Test
     fun mergeDeepMergesNestedObjectsAndReplacesScalars() {
         val base = Json.parseToJsonElement("""{"a":{"x":1,"y":2},"b":1}""").jsonObject
@@ -222,58 +226,58 @@ class ConfigLogicTest {
     }
 
     @Test
-    fun pickFreeUpstreamReturnsFirstFreeInDeclarationOrder() {
+    fun pickFreeUpstreamReturnsFirstFreeInDeclarationOrder() = runTest {
         val active = mapOf("u1" to UpstreamCounter(1), "u2" to UpstreamCounter(2))
         val pool = listOf(
             UpstreamConf("u1", "p", "m", 1, null),
             UpstreamConf("u2", "p", "m", 2, null),
         )
-        val up = pickFreeUpstream(pool, active, emptySet())
+        val up = pickFreeUpstream(pool, active, emptySet(), noBackoff)
         assertEquals("u1", up?.id)
         // слот реально занят
         assertEquals(1, active.getValue("u1").current)
     }
 
     @Test
-    fun pickFreeUpstreamSkipsExcluded() {
+    fun pickFreeUpstreamSkipsExcluded() = runTest {
         val active = mapOf("u1" to UpstreamCounter(1), "u2" to UpstreamCounter(2))
         val pool = listOf(
             UpstreamConf("u1", "p", "m", 1, null),
             UpstreamConf("u2", "p", "m", 2, null),
         )
-        val up = pickFreeUpstream(pool, active, setOf("u1"))
+        val up = pickFreeUpstream(pool, active, setOf("u1"), noBackoff)
         assertEquals("u2", up?.id)
     }
 
     @Test
-    fun pickFreeUpstreamReturnsNullWhenAllBusy() {
+    fun pickFreeUpstreamReturnsNullWhenAllBusy() = runTest {
         val active = mapOf("u1" to UpstreamCounter(1, 1)) // уже на лимите 1
         val pool = listOf(UpstreamConf("u1", "p", "m", 1, null))
-        assertEquals(null, pickFreeUpstream(pool, active, emptySet()))
+        assertEquals(null, pickFreeUpstream(pool, active, emptySet(), noBackoff))
     }
 
     @Test
-    fun pickFreeUpstreamImplementsFailoverOrder() {
+    fun pickFreeUpstreamImplementsFailoverOrder() = runTest {
         // dead исключён (упал ранее) — выбирается следующий живой u1
         val active = mapOf("dead" to UpstreamCounter(1), "u1" to UpstreamCounter(1))
         val pool = listOf(
             UpstreamConf("dead", "p", "m", 1, null),
             UpstreamConf("u1", "p", "m", 1, null),
         )
-        val up = pickFreeUpstream(pool, active, setOf("dead"))
+        val up = pickFreeUpstream(pool, active, setOf("dead"), noBackoff)
         assertEquals("u1", up?.id)
     }
 
     @Test
-    fun pickFreeUpstreamExhaustsConcurrencyThenReturnsNull() {
+    fun pickFreeUpstreamExhaustsConcurrencyThenReturnsNull() = runTest {
         val active = mapOf("u1" to UpstreamCounter(1), "u2" to UpstreamCounter(1))
         val pool = listOf(
             UpstreamConf("u1", "p", "m", 1, null),
             UpstreamConf("u2", "p", "m", 1, null),
         )
-        assertEquals("u1", pickFreeUpstream(pool, active, emptySet())?.id)
-        assertEquals("u2", pickFreeUpstream(pool, active, emptySet())?.id)
-        assertEquals(null, pickFreeUpstream(pool, active, emptySet())?.id)
+        assertEquals("u1", pickFreeUpstream(pool, active, emptySet(), noBackoff)?.id)
+        assertEquals("u2", pickFreeUpstream(pool, active, emptySet(), noBackoff)?.id)
+        assertEquals(null, pickFreeUpstream(pool, active, emptySet(), noBackoff)?.id)
     }
 
     @Test
@@ -289,6 +293,7 @@ class ConfigLogicTest {
             "Proxy-Connection" to listOf("keep-alive"),
             "Upgrade" to listOf("h2c"),
             "Authorization" to listOf("Bearer client-secret"),
+            "Content-Type" to listOf("application/x-www-form-urlencoded"),
             "Accept" to listOf("*/*"),
         )
         val out = headersToForward(req)
@@ -297,6 +302,7 @@ class ConfigLogicTest {
         assertEquals(listOf("*/*"), out["Accept"])
         assertEquals(3, out.size)
         assertEquals(null, out["Authorization"])
+        assertEquals(null, out["Content-Type"])
     }
 
     @Test
@@ -312,6 +318,32 @@ class ConfigLogicTest {
         assertEquals(listOf("s"), out["x-opencode-session"])
     }
 
+    @Test
+    fun formatHeadersForLogMasksSecretsAndKeepsOthers() {
+        val line = formatHeadersForLog(
+            headersOf(
+                "X-Opencode-Session" to listOf("abc-123"),
+                "Authorization" to listOf("Bearer super-secret"),
+                "x-api-key" to listOf("key-1"),
+                "Cookie" to listOf("session=deadbeef"),
+            ),
+        )
+        assertTrue(line.contains("X-Opencode-Session=abc-123"))
+        assertTrue(line.contains("Authorization=***"))
+        assertTrue(line.contains("x-api-key=***"))
+        assertTrue(line.contains("Cookie=***"))
+        assertFalse(line.contains("super-secret"))
+        assertFalse(line.contains("deadbeef"))
+    }
+
+    @Test
+    fun formatHeadersForLogJoinsMultipleValues() {
+        val line = formatHeadersForLog(
+            headersOf("X-Custom" to listOf("a", "b")),
+        )
+        assertEquals("X-Custom=a|b", line)
+    }
+
     @Test
     fun rebuildFromChunksPreservesAllUpstreamFields() {
         val sse = """
@@ -354,4 +386,261 @@ class ConfigLogicTest {
         val err = out["error"]?.jsonObject ?: error("error block missing")
         assertEquals("Unsupported field 'foo'", err["message"]?.jsonPrimitive?.content)
     }
+
+    @Test
+    fun sha256MatchesKnownVectors() {
+        assertEquals(
+            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+            sha256Hex(""),
+        )
+        assertEquals(
+            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+            sha256Hex("abc"),
+        )
+        assertEquals(
+            "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+            sha256Hex("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"),
+        )
+    }
+
+    @Test
+    fun sessionPrefixHashesAreStableWhenHistoryGrows() {
+        val first = Json.parseToJsonElement(
+            """{"messages":[{"role":"system","content":"S"},{"role":"user","content":"hi"}]}""",
+        ).jsonObject
+        val second = Json.parseToJsonElement(
+            """{"messages":[{"role":"system","content":"S"},{"role":"user","content":"hi"},{"role":"assistant","content":"yo"},{"role":"user","content":"again"}]}""",
+        ).jsonObject
+
+        val h1 = sessionPrefixHashes(first)
+        val h2 = sessionPrefixHashes(second)
+
+        // Цепочка начинается с первого user — system-преамбула не хэшируется.
+        assertEquals(1, h1.size)
+        assertEquals(3, h2.size)
+        assertEquals(h1, h2.take(1))
+        assertEquals(h1.last(), h2[0])
+    }
+
+    @Test
+    fun sessionPrefixHashesIgnoreLeadingSystemSoSharedPromptDoesNotCollide() {
+        val a = Json.parseToJsonElement(
+            """{"messages":[{"role":"system","content":"SAME"},{"role":"user","content":"session A"}]}""",
+        ).jsonObject
+        val b = Json.parseToJsonElement(
+            """{"messages":[{"role":"system","content":"SAME"},{"role":"user","content":"session B"}]}""",
+        ).jsonObject
+        // разные первые user-сообщения → разные хэши, несмотря на общий system
+        assertFalse(sessionPrefixHashes(a) == sessionPrefixHashes(b))
+    }
+
+    @Test
+    fun sessionPrefixHashesFallBackToWholeBodyWithoutMessages() {
+        val body = Json.parseToJsonElement("""{"model":"m"}""").jsonObject
+        assertEquals(listOf(sha256Hex(body.toString())), sessionPrefixHashes(body))
+    }
+
+    @Test
+    fun sessionRegistryReusesIdByLongestCommonPrefix() {
+        val reg = SessionRegistry()
+        val first = reg.resolveLocked(listOf("H1"), 0)
+        assertEquals("H1", first)
+
+        // история выросла: [H1, H2, H3] — самый длинный известный префикс H1
+        val next = reg.resolveLocked(listOf("H1", "H2", "H3"), 1)
+        assertEquals("H1", next)
+
+        // и дальше — id не меняется
+        val deep = reg.resolveLocked(listOf("H1", "H2", "H3", "H4"), 2)
+        assertEquals("H1", deep)
+    }
+
+    @Test
+    fun sessionRegistryCreatesNewIdForDifferentHistory() {
+        val reg = SessionRegistry()
+        assertEquals("A1", reg.resolveLocked(listOf("A1"), 0))
+        assertEquals("B1", reg.resolveLocked(listOf("B1"), 0))
+        assertEquals("A1", reg.resolveLocked(listOf("A1", "A2"), 0))
+    }
+
+    @Test
+    fun sessionRegistryEvictsLruWhenOverCapacity() {
+        val reg = SessionRegistry(maxSessions = 2, ttlMillis = Long.MAX_VALUE)
+        reg.resolveLocked(listOf("A1"), 0)
+        reg.resolveLocked(listOf("B1"), 1)
+        reg.resolveLocked(listOf("C1"), 2) // A вытеснена
+        // a1 больше неизвестен → новая сессия с id = хэш всей истории A2
+        assertEquals("A2", reg.resolveLocked(listOf("A1", "A2"), 3))
+    }
+
+    @Test
+    fun sessionRegistryEvictsExpiredByTtl() {
+        val reg = SessionRegistry(maxSessions = 100, ttlMillis = 1000)
+        reg.resolveLocked(listOf("A1"), 0)
+        reg.resolveLocked(listOf("B1"), 2000) // A протухла
+        assertEquals("A2", reg.resolveLocked(listOf("A1", "A2"), 2001))
+    }
+
+    @Test
+    fun parseConfigReadsSessionHeader() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+                session_header: x-opencode-session
+              - id: p2
+                url: "https://y.ru/api/v1"
+            models:
+              - name: m1
+                upstreams: []
+        """.trimIndent()
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+        assertEquals("x-opencode-session", cfg.providers[0].session_header)
+        assertEquals(null, cfg.providers[1].session_header)
+    }
+
+    @Test
+    fun parseConfigReadsThinkTagsOnProviderAndUpstream() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+                think_tags: split
+              - id: p2
+                url: "https://y.ru/api/v1"
+            upstreams:
+              - id: u1
+                provider: p1
+                model: real-1
+                think_tags: strip
+              - id: u2
+                provider: p1
+                model: real-2
+            models:
+              - name: m1
+                upstreams: [u1, u2]
+        """.trimIndent()
+
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+
+        assertEquals("split", cfg.providers[0].think_tags)
+        assertEquals(null, cfg.providers[1].think_tags)
+        assertEquals("strip", cfg.upstreams[0].think_tags)
+        assertEquals(null, cfg.upstreams[1].think_tags)
+    }
+
+    @Test
+    fun effectiveThinkTagsPrefersUpstreamThenProviderWithTolerantParse() {
+        val upSplit = UpstreamConf("u1", "p", "m", think_tags = "split")
+        val upNull = UpstreamConf("u2", "p", "m", think_tags = null)
+        val prov = { tt: String? -> ProviderConf("p", "https://x", think_tags = tt) }
+
+        // значение у апстрима — берётся оно, провайдер игнорируется
+        assertEquals("split", effectiveThinkTags(upSplit, null))
+        assertEquals("split", effectiveThinkTags(upSplit, prov("strip")))
+
+        // апстрим null — берётся провайдерский
+        assertEquals("split", effectiveThinkTags(upNull, prov("split")))
+        assertEquals("strip", effectiveThinkTags(upNull, prov("strip")))
+        assertEquals("split", effectiveThinkTags(upNull, prov("true")))
+        assertEquals("off", effectiveThinkTags(upNull, prov("false")))
+        assertEquals("off", effectiveThinkTags(upNull, prov("yes")))
+
+        // нигде нет — "off"
+        assertEquals("off", effectiveThinkTags(upNull, prov(null)))
+        assertEquals("off", effectiveThinkTags(upNull, null))
+    }
+
+    @Test
+    fun parseConfigReadsReasoningFieldAndEmptyOkOnProvider() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+                reasoning_field: reasoning_content
+                reasoning_empty_ok: true
+              - id: p2
+                url: "https://y.ru/api/v1"
+                reasoning_empty_ok: false
+            models:
+              - name: m1
+                upstreams: []
+        """.trimIndent()
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+        assertEquals("reasoning_content", cfg.providers[0].reasoning_field)
+        assertEquals(true, cfg.providers[0].reasoning_empty_ok)
+        assertEquals(null, cfg.providers[1].reasoning_field)
+        assertEquals(false, cfg.providers[1].reasoning_empty_ok)
+    }
+
+    @Test
+    fun parseConfigDefaultsReasoningFieldsWhenAbsent() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+            models:
+              - name: m1
+                upstreams: []
+        """.trimIndent()
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+        assertEquals(null, cfg.providers[0].reasoning_field)
+        assertEquals(false, cfg.providers[0].reasoning_empty_ok)
+    }
+
+    @Test
+    fun parseConfigReadsFirstByteTimeoutOnProviderAndUpstream() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+                first_byte_timeout: PT45S
+              - id: p2
+                url: "https://y.ru/api/v1"
+            upstreams:
+              - id: u1
+                provider: p1
+                model: real-1
+                first_byte_timeout: PT0S
+              - id: u2
+                provider: p2
+                model: real-2
+            models:
+              - name: m1
+                upstreams: [u1, u2]
+        """.trimIndent()
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+        assertEquals(45.seconds, cfg.providers[0].first_byte_timeout)
+        assertEquals(null, cfg.providers[1].first_byte_timeout)
+        assertEquals(0.seconds, cfg.upstreams[0].first_byte_timeout)
+        assertEquals(null, cfg.upstreams[1].first_byte_timeout)
+    }
+
+    @Test
+    fun parseConfigReadsProbeIntervalOnProviderAndUpstream() {
+        val yaml = """
+            providers:
+              - id: p1
+                url: "https://x.ru/api/v1"
+                probe_interval: PT2S
+              - id: p2
+                url: "https://y.ru/api/v1"
+            upstreams:
+              - id: u1
+                provider: p1
+                model: real-1
+                probe_interval: PT0S
+              - id: u2
+                provider: p2
+                model: real-2
+            models:
+              - name: m1
+                upstreams: [u1, u2]
+        """.trimIndent()
+        val cfg = parseConfig(Yaml.decodeYamlFromString(yaml))
+        assertEquals(2.seconds, cfg.providers[0].probe_interval)
+        assertEquals(null, cfg.providers[1].probe_interval)
+        assertEquals(0.seconds, cfg.upstreams[0].probe_interval)
+        assertEquals(null, cfg.upstreams[1].probe_interval)
+    }
 }

src/commonTest/kotlin/pw/binom/llmproxy/FirstByteTimeoutTest.kt

@@ -0,0 +1,218 @@
+package pw.binom.llmproxy
+
+import io.ktor.utils.io.ByteChannel
+import io.ktor.utils.io.close
+import io.ktor.utils.io.readAvailable
+import io.ktor.utils.io.writeFully
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+
+/**
+ * Тесты watchdog'а на первый байт тела стрим-ответа.
+ *
+ * Сценарии:
+ * - Апстрим не прислал ничего за N мс → [FirstByteTimeoutException] на первой
+ *   попытке чтения (после первой попытки watchdog отключается).
+ * - Апстрим закрыл канал до таймаута, не прислав данных → возврат EOF (-1 /
+ *   null), НЕ [FirstByteTimeoutException].
+ * - Апстрим прислал первый байт вовремя → читаем его, watchdog отключён.
+ * - Когда таймаут не задан (`null`) → читаем без лимита (как и было).
+ */
+class FirstByteTimeoutTest {
+
+    /** Окно для watchdog'а в тестах: виртуальное время `runTest` его мгновенно прокручивает. */
+    private val watchWindow = 100.milliseconds
+
+    @Test
+    fun readAvailableTimesOutWhenNoBytesAndNotClosed() = runTest {
+        val src = ByteChannel(autoFlush = true)
+        val buf = ByteArray(64)
+        val done = CompletableDeferred<Throwable?>()
+
+        launch {
+            try {
+                readAvailableWithTimeout(src, buf, watchWindow.inWholeMilliseconds)
+                done.complete(AssertionError("expected FirstByteTimeoutException"))
+            } catch (e: FirstByteTimeoutException) {
+                done.complete(null)
+                assertEquals(watchWindow.inWholeMilliseconds, e.timeoutMs)
+            } catch (e: Throwable) {
+                done.complete(e)
+            }
+        }
+        advanceTimeBy(watchWindow.inWholeMilliseconds + 50)
+        runCurrent()
+        val err = done.await()
+        if (err != null) throw err
+    }
+
+    @Test
+    fun readAvailableReturnsEofImmediatelyWhenChannelClosedEmpty() = runTest {
+        // Канал сразу закрыт без данных: -1 (EOF), никакого таймаута.
+        val src = ByteChannel(autoFlush = true)
+        src.close(null)
+        val buf = ByteArray(64)
+
+        val n = readAvailableWithTimeout(src, buf, watchWindow.inWholeMilliseconds)
+        assertEquals(-1, n, "закрытый пустой канал → EOF, не таймаут")
+    }
+
+    @Test
+    fun readAvailableReturnsBytesWhenDataArrivesInTime() = runTest {
+        val src = ByteChannel(autoFlush = true)
+        val payload = "hello".encodeToByteArray()
+        src.writeFully(payload)
+        val buf = ByteArray(64)
+
+        val n = readAvailableWithTimeout(src, buf, watchWindow.inWholeMilliseconds)
+        assertEquals(payload.size, n)
+        assertEquals(payload.decodeToString(), buf.decodeToString(0, n))
+    }
+
+    @Test
+    fun readLineTimesOutWhenNoLinesAndNotClosed() = runTest {
+        val src = ByteChannel(autoFlush = true)
+        val done = CompletableDeferred<Throwable?>()
+
+        launch {
+            try {
+                readLineWithTimeout(src, watchWindow.inWholeMilliseconds)
+                done.complete(AssertionError("expected FirstByteTimeoutException"))
+            } catch (e: FirstByteTimeoutException) {
+                done.complete(null)
+            } catch (e: Throwable) {
+                done.complete(e)
+            }
+        }
+        advanceTimeBy(watchWindow.inWholeMilliseconds + 50)
+        runCurrent()
+        val err = done.await()
+        if (err != null) throw err
+    }
+
+    @Test
+    fun readLineReturnsNullWhenChannelClosedEmpty() = runTest {
+        // Закрытый пустой канал → null (EOF), не таймаут. Это критично: иначе бы
+        // мы фейловерили легитимные короткие ответы, где апстрим закрыл стрим
+        // до первой строки.
+        val src = ByteChannel(autoFlush = true)
+        src.close(null)
+
+        val line = readLineWithTimeout(src, watchWindow.inWholeMilliseconds)
+        assertEquals(null, line)
+    }
+
+    @Test
+    fun rawStreamTimesOutWhenUpstreamSilent() = runTest {
+        // Сырой passthrough: апстрим молчит вечно → на первой попытке чтения
+        // вылетает FirstByteTimeoutException, в out ничего не пишется.
+        val src = ByteChannel(autoFlush = true)
+        val out = ByteChannel(autoFlush = true)
+        val done = CompletableDeferred<Throwable?>()
+
+        launch {
+            try {
+                out.streamRawWithDoneContract(src, watchWindow)
+                done.complete(AssertionError("expected FirstByteTimeoutException"))
+            } catch (e: FirstByteTimeoutException) {
+                done.complete(null)
+            } catch (e: Throwable) {
+                done.complete(e)
+            }
+        }
+        advanceTimeBy(watchWindow.inWholeMilliseconds + 50)
+        runCurrent()
+        val err = done.await()
+        if (err != null) throw err
+
+        // Подтверждаем, что в out ничего не утекло.
+        out.close(null)
+        val buf = ByteArray(64)
+        val n = out.readAvailable(buf)
+        assertEquals(-1, n, "до таймаута клиенту ничего не должно уйти")
+    }
+
+    @Test
+    fun thinkStreamTimesOutWhenUpstreamSilent() = runTest {
+        // SSE-вариант: первая строка не приходит → FirstByteTimeoutException,
+        // в out ничего не пишется.
+        val src = ByteChannel(autoFlush = true)
+        val out = ByteChannel(autoFlush = true)
+        val done = CompletableDeferred<Throwable?>()
+
+        launch {
+            try {
+                out.streamSseWithThinkTags(src, "split", watchWindow)
+                done.complete(AssertionError("expected FirstByteTimeoutException"))
+            } catch (e: FirstByteTimeoutException) {
+                done.complete(null)
+            } catch (e: Throwable) {
+                done.complete(e)
+            }
+        }
+        advanceTimeBy(watchWindow.inWholeMilliseconds + 50)
+        runCurrent()
+        val err = done.await()
+        if (err != null) throw err
+
+        out.close(null)
+        val buf = ByteArray(64)
+        val n = out.readAvailable(buf)
+        assertEquals(-1, n)
+    }
+
+    @Test
+    fun thinkStreamFirstLineInTimeThenReadsUnlimited() = runTest {
+        // Первый байт/строка пришли вовремя → watchdog выключен, остальной
+        // поток читается обычным порядком. Проверяем, что НЕ бросило
+        // FirstByteTimeoutException и данные дошли до out.
+        val src = ByteChannel(autoFlush = true)
+        val out = ByteChannel(autoFlush = true)
+        val payload = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n"
+        src.writeFully(payload.encodeToByteArray())
+        src.close(null)
+
+        out.streamSseWithThinkTags(src, "split", watchWindow)
+
+        out.close(null)
+        val sb = StringBuilder()
+        val buf = ByteArray(256)
+        while (true) {
+            val n = out.readAvailable(buf)
+            if (n == -1) break
+            if (n > 0) sb.append(buf.decodeToString(0, n))
+        }
+        assertTrue(sb.toString().contains("data:"), "данные дошли до out: $sb")
+    }
+
+    @Test
+    fun effectiveFirstByteTimeoutPrefersUpstreamThenProviderThenDefault() {
+        // upstream > provider > default
+        val provider = ProviderConf("p", "https://x", "", null, null, first_byte_timeout = 20.milliseconds)
+        val upstream = UpstreamConf("u", "p", "m", null, null, null, null, first_byte_timeout = 5.milliseconds)
+        val upstreamNoOwn = UpstreamConf("u", "p", "m")
+
+        assertEquals(5.milliseconds, effectiveFirstByteTimeout(upstream, provider))
+        assertEquals(20.milliseconds, effectiveFirstByteTimeout(upstreamNoOwn, provider))
+        assertEquals(DEFAULT_FIRST_BYTE_TIMEOUT, effectiveFirstByteTimeout(upstreamNoOwn, null))
+    }
+
+    @Test
+    fun effectiveFirstByteTimeoutZeroDisablesWatchdog() {
+        // 0s / PT0S → null: passthrough без watchdog'а.
+        val up = UpstreamConf("u", "p", "m", null, null, null, null, first_byte_timeout = 0.milliseconds)
+        assertEquals(null, effectiveFirstByteTimeout(up, null))
+
+        val providerZero = ProviderConf("p", "https://x", "", null, null, first_byte_timeout = 0.milliseconds)
+        val upNoOwn = UpstreamConf("u", "p", "m")
+        assertEquals(null, effectiveFirstByteTimeout(upNoOwn, providerZero))
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/HealthProberTest.kt

@@ -0,0 +1,148 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+
+class HealthProberTest {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    @Test
+    fun effectiveProbeIntervalPrefersUpstreamThenProviderThenDefault() {
+        val provider = ProviderConf("p", "https://x", "", null, null, probe_interval = 2.seconds)
+        val upstream = UpstreamConf("u", "p", "m", null, null, null, null, null, probe_interval = 5.milliseconds)
+        val upstreamNoOwn = UpstreamConf("u2", "p", "m")
+        assertEquals(5.milliseconds, effectiveProbeInterval(upstream, provider))
+        assertEquals(2.seconds, effectiveProbeInterval(upstreamNoOwn, provider))
+        assertEquals(DEFAULT_PROBE_INTERVAL, effectiveProbeInterval(upstreamNoOwn, null))
+    }
+
+    @Test
+    fun effectiveProbeIntervalZeroDisablesProber() {
+        val up = UpstreamConf("u", "p", "m", null, null, null, null, null, probe_interval = 0.milliseconds)
+        assertNull(effectiveProbeInterval(up, null))
+
+        val providerZero = ProviderConf("p", "https://x", "", null, null, probe_interval = 0.milliseconds)
+        assertNull(effectiveProbeInterval(UpstreamConf("u2", "p", "m"), providerZero))
+    }
+
+    @Test
+    fun buildProbeBodyIsMinimalChatWithModelReplacedAndPatchesApplied() {
+        val provider = ProviderConf(
+            "p", "https://x", "", null,
+            Json.parseToJsonElement("""{"provider":{"allow_fallbacks":false}}""").jsonObject,
+            probe_interval = 1.seconds,
+        )
+        val up = UpstreamConf(
+            "u", "p", "real-1", null,
+            Json.parseToJsonElement("""{"temperature":0.5}""").jsonObject,
+            null, null, null, 1.seconds,
+        )
+
+        val body = buildProbeBody(up, provider)
+
+        assertEquals("real-1", body["model"]?.jsonPrimitive?.content)
+        assertEquals("2+2=?", body["messages"]?.jsonArray?.first()?.jsonObject?.get("content")?.jsonPrimitive?.content)
+        assertEquals("true", body["stream"]?.jsonPrimitive?.content)
+        assertEquals("4", body["max_tokens"]?.jsonPrimitive?.content)
+        assertEquals("false", body["provider"]?.jsonObject?.get("allow_fallbacks")?.jsonPrimitive?.content)
+        assertEquals("0.5", body["temperature"]?.jsonPrimitive?.content)
+    }
+
+    @Test
+    fun buildProbeBodyIgnoresModelPatch() {
+        val up = UpstreamConf("u", "p", "real-1")
+        val provider = ProviderConf("p", "https://x")
+        val body = buildProbeBody(up, provider)
+        assertEquals(
+            """{"model":"real-1","messages":[{"role":"user","content":"2+2=?"}],"max_tokens":4,"stream":true}""",
+            body.toString(),
+        )
+    }
+
+    @Test
+    fun probeLoopRecoversUpstreamWhenPingSucceeds() = runTest {
+        val provider = ProviderConf("p", "https://x", "", null, null, backoff = 5.minutes)
+        val up = UpstreamConf("u", "p", "m", null, null, null, backoff = 5.minutes, probe_interval = 5.milliseconds)
+        val backoff = BackoffRegistry(mapOf("p" to provider), mapOf("u" to up))
+        backoff.recordFailure(up)
+        assertEquals(true, backoff.isCooling(up))
+
+        val metrics = MetricsRegistry()
+        val prober = HealthProber(
+            providersById = mapOf("p" to provider),
+            upstreams = listOf(up),
+            http = createHttpClient(),
+            backoff = backoff,
+            metrics = metrics,
+            scope = this,
+        )
+        var pings = 0
+        val job = launch {
+            prober.probeLoop(up, 5.milliseconds) { pinged ->
+                pings++
+                assertEquals("u", pinged.id)
+                true
+            }
+        }
+        runUntil { pings >= 1 }
+        // успех уже зафиксирован (recordSuccess) — даём циклу несколько
+        // итераций и убеждаемся, что повторных пингов не было
+        delay(10.milliseconds)
+        job.cancel()
+
+        assertEquals(1, pings)
+        assertEquals(false, backoff.isCooling(up))
+    }
+
+    @Test
+    fun probeLoopKeepsCoolingWhenPingFails() = runTest {
+        val provider = ProviderConf("p", "https://x", "", null, null, backoff = 5.minutes)
+        val up = UpstreamConf("u", "p", "m", null, null, null, backoff = 5.minutes, probe_interval = 5.milliseconds)
+        val backoff = BackoffRegistry(mapOf("p" to provider), mapOf("u" to up))
+        backoff.recordFailure(up)
+
+        val metrics = MetricsRegistry()
+        val prober = HealthProber(
+            providersById = mapOf("p" to provider),
+            upstreams = listOf(up),
+            http = createHttpClient(),
+            backoff = backoff,
+            metrics = metrics,
+            scope = this,
+        )
+        var pings = 0
+        val job = launch {
+            prober.probeLoop(up, 5.milliseconds) { _ ->
+                pings++
+                false
+            }
+        }
+        runUntil { pings >= 2 }
+        job.cancel()
+
+        assertEquals(true, backoff.isCooling(up))
+    }
+
+    private suspend fun TestScope.runUntil(condition: () -> Boolean) {
+        var i = 0
+        while (!condition() && i < 10_000) {
+            delay(1)
+            i++
+        }
+        if (!condition()) throw AssertionError("condition not met in time")
+    }
+
+}

src/commonTest/kotlin/pw/binom/llmproxy/MetricsTest.kt

@@ -0,0 +1,74 @@
+package pw.binom.llmproxy
+
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Duration.Companion.seconds
+
+class MetricsTest {
+
+    private val p = ProviderConf(id = "p", url = "https://p", backoff = 30.seconds)
+    private val a = UpstreamConf(id = "a", provider = "p", model = "m1")
+    private val b = UpstreamConf(id = "b", provider = "p", model = "m2")
+    private val cfg = Config(
+        server = ServerConf(),
+        providers = listOf(p),
+        upstreams = listOf(a, b),
+        models = emptyList(),
+    )
+
+    @Test
+    fun requestCounters() = runTest {
+        val m = MetricsRegistry()
+        m.record("my-gpt", a, "ok")
+        m.record("my-gpt", a, "ok")
+        m.record("my-gpt", a, "429")
+        m.record("my-gpt", b, "5xx")
+        val text = m.render(cfg, mapOf("a" to UpstreamCounter(4), "b" to UpstreamCounter(4)), BackoffRegistry(emptyMap(), emptyMap()))
+        assertTrue(text.contains("llm_proxy_requests_total{model=\"my-gpt\",upstream=\"a\",provider=\"p\",result=\"ok\"} 2\n"), "ok=2: $text")
+        assertTrue(text.contains("llm_proxy_requests_total{model=\"my-gpt\",upstream=\"a\",provider=\"p\",result=\"429\"} 1\n"), "429=1: $text")
+        assertTrue(text.contains("llm_proxy_requests_total{model=\"my-gpt\",upstream=\"b\",provider=\"p\",result=\"5xx\"} 1\n"), "5xx=1: $text")
+        assertTrue(text.contains("# TYPE llm_proxy_requests_total counter"), "TYPE: $text")
+    }
+
+    @Test
+    fun inflightGauge() = runTest {
+        val m = MetricsRegistry()
+        val text = m.render(cfg, mapOf("a" to UpstreamCounter(4, 3), "b" to UpstreamCounter(4)), BackoffRegistry(emptyMap(), emptyMap()))
+        assertTrue(text.contains("llm_proxy_upstream_inflight{upstream=\"a\",provider=\"p\"} 3\n"), text)
+        assertTrue(text.contains("llm_proxy_upstream_inflight{upstream=\"b\",provider=\"p\"} 0\n"), text)
+    }
+
+    @Test
+    fun backoffGauges() = runTest {
+        val backoff = BackoffRegistry(mapOf("p" to p), mapOf("a" to a, "b" to b))
+        assertEquals(1.seconds, backoff.recordFailure(a))
+        val text = MetricsRegistry().render(cfg, mapOf("a" to UpstreamCounter(4), "b" to UpstreamCounter(4)), backoff)
+        // общий скоуп провайдера: сбой у a виден и у b
+        assertTrue(text.contains("llm_proxy_upstream_fail_streak{upstream=\"a\",provider=\"p\"} 1\n"), text)
+        assertTrue(text.contains("llm_proxy_upstream_fail_streak{upstream=\"b\",provider=\"p\"} 1\n"), text)
+        assertTrue(Regex("llm_proxy_upstream_cooling_seconds\\{upstream=\"a\",provider=\"p\"\\} (0|1)").containsMatchIn(text), text)
+        assertTrue(Regex("llm_proxy_upstream_cooling_seconds\\{upstream=\"b\",provider=\"p\"\\} (0|1)").containsMatchIn(text), text)
+    }
+
+    @Test
+    fun labelEscaping() = runTest {
+        val m = MetricsRegistry()
+        m.record("we\"ird\nmodel", a, "ok")
+        val text = m.render(cfg, mapOf("a" to UpstreamCounter(4)), BackoffRegistry(emptyMap(), emptyMap()))
+        assertTrue(text.contains("model=\"we\\\"ird\\nmodel\""), text)
+    }
+
+    @Test
+    fun statusClasses() {
+        assertEquals("ok", statusClass(200))
+        assertEquals("ok", statusClass(302))
+        assertEquals("4xx", statusClass(400))
+        assertEquals("4xx", statusClass(499))
+        assertEquals("429", statusClass(429))
+        assertEquals("402", statusClass(402))
+        assertEquals("5xx", statusClass(500))
+        assertEquals("5xx", statusClass(599))
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/NullToleranceTest.kt

@@ -0,0 +1,71 @@
+package pw.binom.llmproxy
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+class NullToleranceTest {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    @Test
+    fun rebuildFromChunksToleratesNullChoices() {
+        // Чанк с choices:null не должен ронять сборку; значимые поля сохраняются.
+        val sse = """
+            data: {"id":"c1","created":123,"model":"m","choices":null}
+            data: {"id":"c1","created":123,"model":"m","choices":[{"index":0,"delta":{"content":"Hi"}}]}
+            data: [DONE]
+        """.trimIndent()
+        val out = json.parseToJsonElement(rebuildFromChunks(sse)).jsonObject
+        assertEquals("c1", out["id"]?.jsonPrimitive?.content)
+        assertEquals("m", out["model"]?.jsonPrimitive?.content)
+        assertEquals(123, out["created"]?.jsonPrimitive?.content?.toLong())
+        val choice = out["choices"]?.jsonArray?.get(0)?.jsonObject
+        assertEquals("Hi", choice?.get("message")?.jsonObject?.get("content")?.jsonPrimitive?.content)
+    }
+
+    @Test
+    fun rebuildFromChunksToleratesNullDeltaToolCalls() {
+        val sse = """
+            data: {"id":"c1","model":"m","choices":[{"index":0,"delta":{"role":"assistant","tool_calls":null},"finish_reason":"stop"}]}
+            data: [DONE]
+        """.trimIndent()
+        val out = json.parseToJsonElement(rebuildFromChunks(sse)).jsonObject
+        val choice = out["choices"]?.jsonArray?.get(0)?.jsonObject
+        assertEquals("assistant", choice?.get("message")?.jsonObject?.get("role")?.jsonPrimitive?.content)
+    }
+
+    @Test
+    fun rebuildFromChunksToleratesNullContent() {
+        val sse = """
+            data: {"id":"c1","model":"m","choices":[{"index":0,"delta":{"role":"assistant","content":null},"finish_reason":"stop"}]}
+            data: [DONE]
+        """.trimIndent()
+        val out = json.parseToJsonElement(rebuildFromChunks(sse)).jsonObject
+        val choice = out["choices"]?.jsonArray?.get(0)?.jsonObject
+        assertEquals("assistant", choice?.get("message")?.jsonObject?.get("role")?.jsonPrimitive?.content)
+    }
+
+    @Test
+    fun hasFinishReasonToleratesNullChoices() {
+        val obj = json.parseToJsonElement("""{"choices":null}""").jsonObject
+        assertFalse(hasFinishReason(obj))
+    }
+
+    @Test
+    fun transformThinkChunkToleratesNullChoices() {
+        val obj = json.parseToJsonElement("""{"choices":null}""").jsonObject
+        assertNull(transformThinkChunk(obj, mutableMapOf(), "split", true))
+    }
+
+    @Test
+    fun transformThinkMessageToleratesNullChoices() {
+        val obj = json.parseToJsonElement("""{"choices":null}""").jsonObject
+        assertNull(transformThinkMessage(obj, "split"))
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ReasoningFieldTest.kt

@@ -0,0 +1,187 @@
+package pw.binom.llmproxy
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+
+class ReasoningFieldTest {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    // Минимальный непустой tool_call для assistant-сообщения.
+    private val TC = """{"id":"t1","type":"function","function":{"name":"f","arguments":"{}"}}"""
+
+    private fun str(obj: JsonObject, key: String): String? = (obj[key] as? JsonPrimitive)?.content
+
+    private fun outMsgs(out: JsonObject): List<JsonObject> =
+        (out["messages"] as? JsonArray)?.mapNotNull { it as? JsonObject } ?: emptyList()
+
+    // Собрать тело `{"messages":[...]}` и прогнать через applyReasoningField.
+    private fun apply(messagesJson: String, field: String?, emptyOk: Boolean): JsonObject {
+        val body = json.parseToJsonElement("""{"messages":[$messagesJson]}""").jsonObject
+        return applyReasoningField(body, field, emptyOk)
+    }
+
+    @Test
+    fun documentedOpencodeShapeGetsNativeReasoningContent() {
+        // Форма клиента opencode: reasoning (строка) + reasoning_details (массив),
+        // нативного поля нет — добавляем его, текст берём из рассуждений.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning":"R","reasoning_details":[{"type":"reasoning.text","text":"R","index":0}]}"""
+        val out = apply(m, "reasoning_content", false)
+        val m0 = outMsgs(out)[0]
+        assertEquals("R", str(m0, "reasoning_content"))
+        assertEquals("R", str(m0, "reasoning"))
+        assertTrue((m0["tool_calls"] as? JsonArray)?.isNotEmpty() == true)
+        assertTrue((m0["reasoning_details"] as? JsonArray)?.isNotEmpty() == true)
+    }
+
+    @Test
+    fun reasoningDetailsTextIsCopiedIntoReasoningContent() {
+        // Только reasoning_details (без строки reasoning) — текст всё равно достаётся.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning_details":[{"type":"reasoning.text","text":"D"}]}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("D", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun reasoningDetailsWithForeignTypeAreIgnored() {
+        // Чужой тип (reasoning.encrypted) игнорируется, берётся только reasoning.text.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning_details":[{"type":"reasoning.encrypted","text":"X"},{"type":"reasoning.text","text":"T"}]}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("T", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun multipleReasoningDetailsAreJoinedInOrder() {
+        // Два reasoning.text склеиваются через "\n" в порядке массива.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning_details":[{"type":"reasoning.text","text":"a"},{"type":"reasoning.text","text":"b"}]}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("a\nb", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun existingNonEmptyReasoningContentIsNotOverwritten() {
+        // Непустое нативное поле не перезаписываем текстом из рассуждений.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning":"R","reasoning_content":"нативное"}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("нативное", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun assistantWithoutToolCallsAlsoGetsField() {
+        // DeepSeek требует reasoning_content на КАЖДОМ assistant-сообщении
+        // (thinking-режим), а не только на тех, что с tool_calls.
+        val m = """{"role":"assistant","reasoning":"R","content":"hi"}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("R", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun assistantWithoutReasoningAndNoEmptyOkIsUntouched() {
+        // assistant-сообщение без рассуждений и без tool_calls:
+        // текста нет, emptyOk=false — поле не добавляем.
+        val m = """{"role":"assistant","content":"hi"}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("""{"messages":[$m]}""", out.toString())
+        assertFalse(outMsgs(out)[0].containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun assistantWithoutToolCallsWithEmptyOkFillsEmpty() {
+        // Без tool_calls и без текста, но emptyOk=true — дописываем пустую строку,
+        // т.к. апстриму важно само НАЛИЧИЕ поля.
+        val m = """{"role":"assistant","content":"hi"}"""
+        val out = apply(m, "reasoning_content", true)
+        val m0 = outMsgs(out)[0]
+        assertEquals("", str(m0, "reasoning_content"))
+        assertTrue(m0.containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun assistantWithEmptyToolCallsGetsField() {
+        // Пустой массив tool_calls больше не исключает сообщение из обработки:
+        // текст из reasoning дописывается в нативное поле.
+        val m = """{"role":"assistant","tool_calls":[],"reasoning":"R"}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("R", str(outMsgs(out)[0], "reasoning_content"))
+    }
+
+    @Test
+    fun userAndToolMessagesAreUntouched() {
+        // user/tool/system с теми же полями — не assistant, не трогаем.
+        val msgs = """
+            {"role":"user","tool_calls":[$TC],"reasoning":"R"},
+            {"role":"tool","tool_calls":[$TC],"reasoning":"R"},
+            {"role":"system","tool_calls":[$TC],"reasoning":"R"}
+        """.trimIndent().replace("\n", " ")
+        val out = apply(msgs, "reasoning_content", false)
+        val roles = outMsgs(out).map { str(it, "role") }
+        assertEquals(listOf("user", "tool", "system"), roles)
+        outMsgs(out).forEach { assertFalse(it.containsKey("reasoning_content")) }
+    }
+
+    @Test
+    fun emptyTextWithEmptyOkFillsEmptyString() {
+        // Рассуждений нет вовсе, но emptyOk=true — пишем пустую строку.
+        val m = """{"role":"assistant","tool_calls":[$TC]}"""
+        val out = apply(m, "reasoning_content", true)
+        val m0 = outMsgs(out)[0]
+        assertEquals("", str(m0, "reasoning_content"))
+        assertTrue(m0.containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun emptyTextWithoutEmptyOkLeavesMessageUnchanged() {
+        // Рассуждений нет и emptyOk=false — сообщение не трогаем.
+        val m = """{"role":"assistant","tool_calls":[$TC]}"""
+        val out = apply(m, "reasoning_content", false)
+        assertEquals("""{"messages":[$m]}""", out.toString())
+        assertFalse(outMsgs(out)[0].containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun reasoningFieldNullLeavesBodyUntouched() {
+        // Поле не объявлено у провайдера (null) — тело не трогаем.
+        val m = """{"role":"assistant","tool_calls":[$TC],"reasoning":"R"}"""
+        val out = apply(m, null, false)
+        assertEquals("""{"messages":[$m]}""", out.toString())
+    }
+
+    @Test
+    fun messagesAbsentOrNotArrayLeavesBodyUntouched() {
+        // Нет `messages` — не трогаем.
+        val noMessages = json.parseToJsonElement("""{"model":"m1"}""").jsonObject
+        assertEquals(noMessages.toString(), applyReasoningField(noMessages, "reasoning_content", false).toString())
+
+        // `messages: null` (JsonNull) — тоже не трогаем.
+        val nullMessages = json.parseToJsonElement("""{"messages":null}""").jsonObject
+        val out = applyReasoningField(nullMessages, "reasoning_content", false)
+        assertEquals(nullMessages.toString(), out.toString())
+    }
+
+    @Test
+    fun messageOrderAndOtherFieldsArePreserved() {
+        // Меняется только 2-е (assistant с tool_calls), порядок и остальные поля на месте.
+        val msgs = """
+            {"role":"user","content":"hi"},
+            {"role":"assistant","tool_calls":[$TC],"reasoning":"R","content":""},
+            {"role":"tool","tool_call_id":"t1","content":"ok"},
+            {"role":"user","content":"again"}
+        """.trimIndent().replace("\n", " ")
+        val out = apply(msgs, "reasoning_content", false)
+        val list = outMsgs(out)
+        assertEquals(listOf("user", "assistant", "tool", "user"), list.map { str(it, "role") })
+        assertEquals("R", str(list[1], "reasoning_content"))
+        assertTrue((list[1]["tool_calls"] as? JsonArray)?.isNotEmpty() == true)
+        assertTrue(list[1].containsKey("reasoning"))
+        assertEquals("hi", str(list[0], "content"))
+        assertEquals("ok", str(list[2], "content"))
+        assertEquals("again", str(list[3], "content"))
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/StreamDoneContractTest.kt

@@ -0,0 +1,176 @@
+package pw.binom.llmproxy
+
+import io.ktor.utils.io.ByteChannel
+import io.ktor.utils.io.close
+import io.ktor.utils.io.readAvailable
+import io.ktor.utils.io.writeFully
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlinx.coroutines.test.runTest
+
+class StreamDoneContractTest {
+
+    /** Терминальный маркер, который должен оказаться (или не оказаться) в конце вывода. */
+    private val done = "data: [DONE]\n\n"
+
+    /** Прогнать сырой passthrough-поток через боевую обвязку и вернуть записанные байты как строку. */
+    private suspend fun runRaw(input: String): String {
+        val src = ByteChannel(autoFlush = true)
+        src.writeFully(input.encodeToByteArray())
+        src.close(null)
+        val out = ByteChannel(autoFlush = true)
+        out.streamRawWithDoneContract(src)
+        out.close(null)
+        return readAll(out)
+    }
+
+    /** Прогнать SSE через think-обвязку и вернуть записанные байты как строку. */
+    private suspend fun runThink(input: String, mode: String): String {
+        val src = ByteChannel(autoFlush = true)
+        src.writeFully(input.encodeToByteArray())
+        src.close(null)
+        val out = ByteChannel(autoFlush = true)
+        out.streamSseWithThinkTags(src, mode)
+        out.close(null)
+        return readAll(out)
+    }
+
+    private suspend fun readAll(ch: ByteChannel): String {
+        val sb = StringBuilder()
+        val buf = ByteArray(512)
+        while (true) {
+            val n = ch.readAvailable(buf)
+            if (n == -1) break
+            if (n > 0) sb.append(buf.decodeToString(0, n))
+        }
+        return sb.toString()
+    }
+
+    private fun countOccurrences(text: String, needle: String): Int {
+        var count = 0
+        var from = 0
+        while (true) {
+            val i = text.indexOf(needle, from)
+            if (i < 0) return count
+            count++
+            from = i + needle.length
+        }
+    }
+
+    @Test
+    fun textHelperSeesFinishReason() {
+        assertTrue(hasNonNullFinishReasonText("""{"choices":[{"finish_reason":"stop"}]}"""))
+    }
+
+    @Test
+    fun textHelperIgnoresNullFinishReason() {
+        assertFalse(hasNonNullFinishReasonText("""{"choices":[{"finish_reason":null}]}"""))
+    }
+
+    @Test
+    fun textHelperIgnoresEscapedOccurrenceInContent() {
+        // Экранированное вхождение внутри content — это не поле finish_reason.
+        assertFalse(hasNonNullFinishReasonText("""{"delta":{"content":"\"finish_reason\":\"stop\""}}"""))
+    }
+
+    @Test
+    fun detectorSeesFinishReasonSplitAcrossReads() {
+        // Маркер finish_reason разрезан границей чтения: детектор обязан его собрать.
+        val detector = StreamEndDetector()
+        detector.feed("""{"choices":[{"finish_rea""".encodeToByteArray())
+        detector.feed("""son":"stop"}]}""".encodeToByteArray())
+        assertTrue(detector.sawFinishReason)
+        assertTrue(detector.missingDoneMarker)
+    }
+
+    @Test
+    fun detectorSeesDoneSplitAcrossReads() {
+        // [DONE] разрезан границей чтения: детектор видит его и маркер не нужен.
+        val detector = StreamEndDetector()
+        detector.feed("data: [DO".encodeToByteArray())
+        detector.feed("NE]".encodeToByteArray())
+        assertTrue(detector.sawDone)
+        assertFalse(detector.missingDoneMarker)
+    }
+
+    @Test
+    fun detectorSeesDoneAndFinishReason() {
+        // В одном feed и finish_reason, и [DONE] — дописывать ничего не нужно.
+        val detector = StreamEndDetector()
+        detector.feed("""{"choices":[{"finish_reason":"stop"}]} data: [DONE]""".encodeToByteArray())
+        assertFalse(detector.missingDoneMarker)
+    }
+
+    @Test
+    fun detectorTruncatedStreamNeedsNoMarker() {
+        // Обрыв без finish_reason: маркер не дописываем (усечённый стрим честно остаётся усечённым).
+        val detector = StreamEndDetector()
+        detector.feed("""{"choices":[{"delta":{"content":"hi"}}]}""".encodeToByteArray())
+        assertFalse(detector.missingDoneMarker)
+    }
+
+    @Test
+    fun rawStreamIsByteExactAndAppendsDone() = runTest {
+        // Сырой поток с finish_reason и без [DONE]: байты входа не меняются, маркер дописывается ровно один.
+        val input = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"},\"finish_reason\":\"stop\"}]}\n\n"
+
+        val out = runRaw(input)
+
+        assertEquals(input + done, out, "выход должен быть вход + один маркер")
+        assertEquals(1, countOccurrences(out, done), "маркер должен быть ровно один")
+    }
+
+    @Test
+    fun rawStreamTruncatedPassesThroughUntouched() = runTest {
+        // Обрыв без finish_reason: ни одного [DONE], вход не меняется.
+        val input = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n"
+
+        val out = runRaw(input)
+
+        assertEquals(input, out, "усечённый поток должен уйти как есть")
+        assertEquals(0, countOccurrences(out, "[DONE]"))
+    }
+
+    @Test
+    fun rawStreamKeepsUpstreamDoneMarker() = runTest {
+        // Апстрим прислал свой [DONE]: второй маркер не дописывается.
+        val input = "data: {\"choices\":[{\"finish_reason\":\"stop\"}]}\n\n" + done
+
+        val out = runRaw(input)
+
+        assertEquals(1, countOccurrences(out, done), "маркер не должен дублироваться")
+    }
+
+    @Test
+    fun thinkStreamAppendsDoneWhenUpstreamClosedWithoutMarker() = runTest {
+        // think-обвязка: finish_reason есть, [DONE] нет — маркер дописывается ровно один.
+        val input = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"},\"finish_reason\":\"stop\"}]}\n\n"
+
+        val out = runThink(input, "split")
+
+        assertTrue(out.endsWith(done), "выход должен заканчиваться маркером: $out")
+        assertEquals(1, countOccurrences(out, done), "маркер должен быть ровно один")
+    }
+
+    @Test
+    fun thinkStreamTruncatedNeedsNoMarker() = runTest {
+        // think-обвязка: обрыв без finish_reason — маркер не дописываем.
+        val input = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n\n"
+
+        val out = runThink(input, "split")
+
+        assertEquals(0, countOccurrences(out, "[DONE]"), "при обрыве маркера быть не должно: $out")
+    }
+
+    @Test
+    fun thinkStreamKeepsSingleDone() = runTest {
+        // think-обвязка: finish_reason и собственный [DONE] — маркер остаётся ровно один.
+        val input = "data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"},\"finish_reason\":\"stop\"}]}\n\n" + done
+
+        val out = runThink(input, "split")
+
+        assertEquals(1, countOccurrences(out, done), "маркер не должен дублироваться")
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ThinkTagChunkTest.kt

@@ -0,0 +1,179 @@
+package pw.binom.llmproxy
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+class ThinkTagChunkTest {
+
+    // Литералы тегов OPEN/CLOSE из ThinkTagSplitter собираем из символьных
+    // кусочков, чтобы не записывать тег единой строкой в исходнике.
+    private val openTag = '<' + "think" + '>'
+    private val closeTag = '<' + "/think" + '>'
+    // Маркер рассуждения (5 букв) собираем из Unicode-кодов, без единой строки.
+    private val reasoning = listOf(0x0420, 0x0410, 0x0417, 0x0423, 0x041C)
+        .map { Char(it) }
+        .joinToString("")
+
+    private fun deltaOf(result: String, index: Int): JsonObject =
+        Json.parseToJsonElement(result).jsonObject
+            .get("choices")!!.jsonArray[index].jsonObject
+            .get("delta")!!.jsonObject
+
+    @Test
+    fun chunkSplitHoldsTailAcrossChunks() {
+        // Хвост открывающего тега, разрезанный на границе чанков, переживает
+        // два отдельных вызова через общий splitters (getOrPut по index).
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+
+        // Чанк 1: текст + обрезанный префикс открывающего тега (не завершает тег).
+        val prefix = openTag.dropLast(1)
+        val obj1 = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":"текст$prefix"}}]}""",
+        ).jsonObject
+        val r1 = transformThinkChunk(obj1, splitters, "split", true)
+        assertNotNull(r1)
+        val d1 = deltaOf(r1, 0)
+        assertEquals("текст", d1["content"]!!.jsonPrimitive.content)
+        assertFalse(d1.containsKey("reasoning_content"))
+
+        // Чанк 2 (тот же splitters): остаток открывающего тега + маркер.
+        val rest = openTag.last()
+        val obj2 = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":"$rest$reasoning"}}]}""",
+        ).jsonObject
+        val r2 = transformThinkChunk(obj2, splitters, "split", true)
+        assertNotNull(r2)
+        val d2 = deltaOf(r2, 0)
+        assertFalse(d2.containsKey("content"))
+        assertEquals(reasoning, d2["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun chunkStripRemovesReasoning() {
+        // Режим strip: блок целиком (теги + рассуждения) вырезается,
+        // content склеивается в «AB», ключа reasoning_content нет.
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val c = "A" + openTag + reasoning + closeTag + "B"
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":"$c"}}]}""",
+        ).jsonObject
+        val r = transformThinkChunk(obj, splitters, "strip", false)
+        assertNotNull(r)
+        val d = deltaOf(r, 0)
+        assertEquals("AB", d["content"]!!.jsonPrimitive.content)
+        assertFalse(d.containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun chunkDropsEmptyContentFieldWhenAllGoesToReasoning() {
+        // Режим split: весь контент чанка — think-блок, поэтому content пуст
+        // и ключ убирается из delta, а рассуждения уходят в reasoning_content.
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val c = openTag + reasoning + closeTag
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":"$c"}}]}""",
+        ).jsonObject
+        val r = transformThinkChunk(obj, splitters, "split", true)
+        assertNotNull(r)
+        val d = deltaOf(r, 0)
+        assertFalse(d.containsKey("content"))
+        assertEquals(reasoning, d["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun chunkReturnsNullWhenNoChoices() {
+        // Нет ключа choices — чанк не трогаем, отдаём исходную строку (null).
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val obj = Json.parseToJsonElement("""{"model":"m"}""").jsonObject
+        assertNull(transformThinkChunk(obj, splitters, "split", true))
+    }
+
+    @Test
+    fun chunkReturnsNullWhenDeltaContentNotAString() {
+        // content = null (JsonNull) и content = массив частей — не строка,
+        // значит choice не трогаем, весь чанк не меняется -> null.
+        val s1 = mutableMapOf<Int, ThinkTagSplitter>()
+        val o1 = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":null}}]}""",
+        ).jsonObject
+        assertNull(transformThinkChunk(o1, s1, "split", true))
+
+        val s2 = mutableMapOf<Int, ThinkTagSplitter>()
+        val o2 = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"delta":{"content":[{"type":"text","text":"hi"}]}}]}""",
+        ).jsonObject
+        assertNull(transformThinkChunk(o2, s2, "split", true))
+    }
+
+    @Test
+    fun chunkSeparateSplittersPerIndex() {
+        // Один объект splitters на все три вызова: по каждому index держим
+        // своего сплиттера, поэтому обрезанные хвосты по index не путаются.
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val prefix = openTag.dropLast(1)
+        val rest = openTag.last()
+
+        // Вызов 1: два choice — index 0 «A»+префикс тега, index 1 «B»+тот же префикс.
+        val c1 = """{"choices":[{"index":0,"delta":{"content":"A$prefix"}},{"index":1,"delta":{"content":"B$prefix"}}]}"""
+        val r1 = transformThinkChunk(Json.parseToJsonElement(c1).jsonObject, splitters, "split", true)
+        assertNotNull(r1)
+
+        // Вызов 2: index 1 получает остаток тега + маркер → рассуждения у index 1.
+        val c2 = """{"choices":[{"index":1,"delta":{"content":"$rest${reasoning}1"}}]}"""
+        val r2 = transformThinkChunk(Json.parseToJsonElement(c2).jsonObject, splitters, "split", true)
+        assertNotNull(r2)
+        val d2 = deltaOf(r2, 0)
+        assertEquals(reasoning + "1", d2["reasoning_content"]!!.jsonPrimitive.content)
+
+        // Вызов 3: index 0 получает остаток тега + маркер → рассуждения у index 0.
+        val c3 = """{"choices":[{"index":0,"delta":{"content":"$rest${reasoning}0"}}]}"""
+        val r3 = transformThinkChunk(Json.parseToJsonElement(c3).jsonObject, splitters, "split", true)
+        assertNotNull(r3)
+        val d3 = deltaOf(r3, 0)
+        assertEquals(reasoning + "0", d3["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun chunkKeepsUntouchedChoiceAndFinishReason() {
+        // Первый choice целиком идёт через split; второй без ключа content
+        // (в нём только finish_reason) — остаётся нетронутым, как и был.
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val c = "A" + openTag + reasoning + closeTag + "B"
+        val c1 = """{"choices":[{"index":0,"delta":{"content":"$c"}},{"index":1,"delta":{"finish_reason":"stop"}}]}"""
+        val r = transformThinkChunk(Json.parseToJsonElement(c1).jsonObject, splitters, "split", true)
+        assertNotNull(r)
+        val d0 = deltaOf(r, 0)
+        assertEquals("AB", d0["content"]!!.jsonPrimitive.content)
+        assertEquals(reasoning, d0["reasoning_content"]!!.jsonPrimitive.content)
+        val d1 = deltaOf(r, 1)
+        assertEquals("stop", d1["finish_reason"]!!.jsonPrimitive.content)
+        assertFalse(d1.containsKey("content"))
+    }
+
+    @Test
+    fun chunkIndexDefaultsToZeroWhenAbsent() {
+        // Ключ index отсутствует — оба раза используем сплиттер под индекс 0,
+        // поэтому хвост первого чанка доживал до рассуждений второго.
+        val splitters = mutableMapOf<Int, ThinkTagSplitter>()
+        val prefix = openTag.dropLast(1)
+        val rest = openTag.last()
+
+        val c1 = """{"choices":[{"delta":{"content":"A$prefix"}}]}"""
+        val r1 = transformThinkChunk(Json.parseToJsonElement(c1).jsonObject, splitters, "split", true)
+        assertNotNull(r1)
+
+        val c2 = """{"choices":[{"delta":{"content":"$rest$reasoning"}}]}"""
+        val r2 = transformThinkChunk(Json.parseToJsonElement(c2).jsonObject, splitters, "split", true)
+        assertNotNull(r2)
+        val d2 = deltaOf(r2, 0)
+        assertEquals(reasoning, d2["reasoning_content"]!!.jsonPrimitive.content)
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ThinkTagSplitterTest.kt

@@ -0,0 +1,75 @@
+package pw.binom.llmproxy
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ThinkTagSplitterTest {
+
+    @Test
+    fun offIsPassthroughEvenWithTags() {
+        val s = ThinkTagSplitter("off")
+        assertEquals("<think>x</think>" to "", s.feed("<think>x</think>"))
+        assertEquals("привет\nещё" to "", s.feed("привет\nещё"))
+        assertEquals("" to "", s.finish())
+    }
+
+    @Test
+    fun splitWholeBlockMovesInnerTextToReasoning() {
+        val s = ThinkTagSplitter("split")
+        assertEquals("a" to "r", s.feed("<think>r</think>a"))
+        assertEquals("" to "", s.finish())
+    }
+
+    @Test
+    fun splitTagCutAcrossThreeChunks() {
+        val s = ThinkTagSplitter("split")
+        val first = s.feed("привет <t")
+        assertEquals("привет ", first.first)
+        assertEquals("", first.second)
+        assertEquals("" to "", s.feed("hi"))
+        val third = s.feed("nk>разум")
+        assertEquals("", third.first)
+        assertEquals("разум", third.second)
+        assertEquals("" to "", s.finish())
+    }
+
+    @Test
+    fun splitUnclosedOpenTagLeavesRestInReasoning() {
+        val s = ThinkTagSplitter("split")
+        assertEquals("" to "мысли без конца", s.feed("<think>мысли без конца"))
+        assertEquals("" to "", s.finish())
+
+        // хвост-префикс незакрытого закрывающего тега тоже уезжает в reasoning
+        val s2 = ThinkTagSplitter("split")
+        assertEquals("" to "abc", s2.feed("<think>abc</thi"))
+        assertEquals("" to "</thi", s2.finish())
+    }
+
+    @Test
+    fun splitHandlesSeveralBlocksInOneResponse() {
+        val s = ThinkTagSplitter("split")
+        val first = s.feed("<think>A</think>B<think>C</think>")
+        assertEquals("B", first.first)
+        assertEquals("AC", first.second)
+        assertEquals("text" to "", s.feed("text"))
+        assertEquals("" to "", s.finish())
+    }
+
+    @Test
+    fun stripDropsReasoningAndTags() {
+        val s = ThinkTagSplitter("strip")
+        assertEquals("y" to "", s.feed("<think>x</think>y"))
+        assertEquals("" to "", s.feed("<think>z"))
+        assertEquals("" to "", s.finish())
+    }
+
+    @Test
+    fun heldTailThatTurnedOutNotToBeATagFlowsBackAsContent() {
+        val s = ThinkTagSplitter("split")
+        // "<thi" — полный префикс открывающего тега: хвост держим
+        assertEquals("" to "", s.feed("<thi"))
+        // "x" не продолжает тег: хвост отдаём как обычный текст
+        assertEquals("<thix" to "", s.feed("x"))
+        assertEquals("" to "", s.finish())
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ThinkTagStreamTest.kt

@@ -0,0 +1,179 @@
+package pw.binom.llmproxy
+
+import io.ktor.utils.io.ByteChannel
+import io.ktor.utils.io.close
+import io.ktor.utils.io.readAvailable
+import io.ktor.utils.io.writeFully
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+class ThinkTagStreamTest {
+
+    /** Прогнать SSE-текст через боевую обвязку и вернуть то, что она записала. */
+    private suspend fun runStream(input: String, mode: String): String {
+        val src = ByteChannel(autoFlush = true)
+        src.writeFully(input.encodeToByteArray())
+        src.close(null)
+        val out = ByteChannel(autoFlush = true)
+        out.streamSseWithThinkTags(src, mode)
+        out.close(null)
+        val sb = StringBuilder()
+        val buf = ByteArray(512)
+        while (true) {
+            val n = out.readAvailable(buf)
+            if (n == -1) break
+            if (n > 0) sb.append(buf.decodeToString(0, n))
+        }
+        return sb.toString()
+    }
+
+    // Литералы тегов OPEN/CLOSE из ThinkTagSplitter собираем из символьных
+    // кусочков, чтобы не записывать тег единой строкой в исходнике.
+    private val openTag = '<' + "think" + '>'
+    private val closeTag = '<' + "/think" + '>'
+    // Маркер рассуждения (5 букв) собираем из Unicode-кодов, без единой строки.
+    private val reasoning = listOf(0x0420, 0x0410, 0x0417, 0x0423, 0x041C)
+        .map { Char(it) }
+        .joinToString("")
+
+    /** JSON-нагрузки из data-строк вывода (строки, начинающиеся с «data:»), без служебного [DONE]. */
+    private fun dataPayloads(sse: String): List<String> =
+        sse.lines()
+            .filter { it.startsWith("data:") && it.removePrefix("data:").trim() != "[DONE]" }
+            .map { it.removePrefix("data:").trim() }
+
+    private fun deltaOf(result: String, index: Int): JsonObject =
+        Json.parseToJsonElement(result).jsonObject
+            .get("choices")!!.jsonArray[index].jsonObject
+            .get("delta")!!.jsonObject
+
+    @Test
+    fun streamDoneAndServiceLinesPassThrough() = runTest {
+        // Служебные строки SSE и маркер конца потока должны дойти до клиента без изменений.
+        val input = buildString {
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hi\"}}]}\n")
+            append("\n")
+            append("data: [DONE]\n")
+            append("\n")
+            append("event: ping\n")
+            append("\n")
+            append(": keep-alive\n")
+            append("\n")
+        }
+
+        val out = runStream(input, "split")
+
+        assertTrue(out.contains("data: [DONE]"), "маркер конца потока потерян: $out")
+        assertTrue(out.contains("event: ping"), "служебная строка event потеряна: $out")
+        assertTrue(out.contains(": keep-alive"), "строка-комментарий потеряна: $out")
+        assertTrue(out.contains("hi"), "текстовый чанк потерян: $out")
+    }
+
+    @Test
+    fun streamSplitsReasoningAcrossDataChunks() = runTest {
+        // Хвост открывающего тега разрезан на границе двух data-событий: первое
+        // отдаёт content «A» и хвост держит, второе завершает тег и блок.
+        val prefix = openTag.take(3)
+        val rest = openTag.drop(3)
+        val content2 = rest + reasoning + closeTag + "B"
+        val input = buildString {
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A$prefix\"}}]}\n")
+            append("\n")
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"$content2\"}}]}\n")
+            append("\n")
+        }
+
+        val out = runStream(input, "split")
+        val payloads = dataPayloads(out)
+
+        val last = deltaOf(payloads.last(), 0)
+        assertEquals("B", last["content"]!!.jsonPrimitive.content)
+        assertEquals(reasoning, last["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun streamUnclosedBlockCarriesReasoningInSameChunk() = runTest {
+        // Незакрытый think-блок в конце потока: reasoning отдаётся сразу в том же
+        // чанке, где пришёл, финиш-чанка не появляется — удержанного хвоста нет.
+        val content = "A" + openTag + "МЫСЛИ"
+        val input = buildString {
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"$content\"}}]}\n")
+            append("\n")
+        }
+
+        val payloads = dataPayloads(runStream(input, "split"))
+
+        assertEquals(1, payloads.size, "финиш-чанка быть не должно: $payloads")
+        val delta = deltaOf(payloads.single(), 0)
+        assertEquals("A", delta["content"]!!.jsonPrimitive.content)
+        assertEquals("МЫСЛИ", delta["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun streamFlushesHeldTailOnFinish() = runTest {
+        // Поток обрывается на неполном префиксе открывающего тега: удержанный
+        // хвост не теряется и сбрасывается финиш-чанком в конце.
+        val tail = openTag.take(3)
+        val input = buildString {
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"A$tail\"}}]}\n")
+            append("\n")
+        }
+
+        val payloads = dataPayloads(runStream(input, "split"))
+
+        assertEquals(2, payloads.size, "финиш-чанк с удержанным хвостом потерян: $payloads")
+        val flushed = deltaOf(payloads.last(), 0)
+        assertEquals(tail, flushed["content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun streamInvalidJsonPassesThroughVerbatim() = runTest {
+        // data-строка, которая не является JSON, доходит до клиента без изменений.
+        val input = buildString {
+            append("data: {это не json\n")
+            append("\n")
+        }
+
+        val out = runStream(input, "split")
+
+        assertTrue(out.contains("data: {это не json"), "битая строка не дошла как есть: $out")
+    }
+
+    @Test
+    fun streamChunkWithoutChoicesPassesThrough() = runTest {
+        // Чанк с пустыми choices не меняется и уходит клиенту исходной строкой.
+        val input = buildString {
+            append("data: {\"usage\":{\"total_tokens\":5},\"choices\":[]}\n")
+            append("\n")
+        }
+
+        val out = runStream(input, "split")
+
+        assertTrue(out.contains("\"total_tokens\":5"), "чанк с usage изменился: $out")
+    }
+
+    @Test
+    fun streamModeStripEmitsNoReasoning() = runTest {
+        // Режим strip: текст внутри think-тегов выбрасывается, поля
+        // reasoning_content нет, обычный текст остаётся.
+        val content = "A" + openTag + reasoning + closeTag + "B"
+        val input = buildString {
+            append("data: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"$content\"}}]}\n")
+            append("\n")
+        }
+
+        val out = runStream(input, "strip")
+        val payloads = dataPayloads(out)
+
+        assertTrue(!out.contains("reasoning_content"), "в режиме strip не должно быть reasoning_content: $out")
+        assertEquals(1, payloads.size, "ожидался ровно один чанк: $payloads")
+        assertEquals("AB", deltaOf(payloads.single(), 0)["content"]!!.jsonPrimitive.content, "теги и рассуждение должны быть вырезаны: $payloads")
+    }
+}

src/commonTest/kotlin/pw/binom/llmproxy/ThinkTagTransformTest.kt

@@ -0,0 +1,174 @@
+package pw.binom.llmproxy
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+class ThinkTagTransformTest {
+
+    // Точные литералы тегов из ThinkTagSplitter (OPEN/CLOSE): собираем из
+    // отдельных символов, чтобы не писать тег единой строкой в исходнике.
+    private val openTag = '<' + "think" + '>'
+    private val closeTag = '<' + "/think" + '>'
+
+    private fun messageOf(result: String, index: Int): JsonObject =
+        Json.parseToJsonElement(result).jsonObject
+            .get("choices")!!.jsonArray[index].jsonObject
+            .get("message")!!.jsonObject
+
+    @Test
+    fun splitSingleBlockMovesReasoningAndKeepsOtherFields() {
+        // Проверяем: в режиме split содержимое блока уходит в reasoning_content,
+        // в content остаётся «AB», а служебные поля (model, usage, …) не тронуты.
+        val c = "A" + openTag + "РАЗУМ" + closeTag + "B"
+        val obj = Json.parseToJsonElement(
+            """
+            {"id":"c1","object":"chat.completion","created":123,"model":"m1",
+             "usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3},
+             "system_fingerprint":"sf1",
+             "choices":[{"index":0,"message":{"role":"assistant","content":"$c"},"finish_reason":"stop"}]}
+            """.trimIndent(),
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "split")
+        assertNotNull(result)
+        val out = Json.parseToJsonElement(result).jsonObject
+        val msg = out.get("choices")!!.jsonArray[0].jsonObject.get("message")!!.jsonObject
+        assertEquals("AB", msg["content"]!!.jsonPrimitive.content)
+        assertEquals("РАЗУМ", msg["reasoning_content"]!!.jsonPrimitive.content)
+        assertEquals("m1", out["model"]!!.jsonPrimitive.content)
+        assertEquals(3, out["usage"]!!.jsonObject["total_tokens"]!!.jsonPrimitive.content.toInt())
+    }
+
+    @Test
+    fun splitTwoBlocksConcatenateInOrder() {
+        // Проверяем порядок конкатенации reasoning, когда два think-блока идут подряд.
+        val c = openTag + "ПЕРВЫЙ" + closeTag + "X" + openTag + "ВТОРОЙ" + closeTag
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"index":0,"message":{"content":"$c"}}]}""",
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "split")
+        assertNotNull(result)
+        val msg = messageOf(result, 0)
+        assertEquals("X", msg["content"]!!.jsonPrimitive.content)
+        assertEquals("ПЕРВЫЙВТОРОЙ", msg["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun splitAppendsToExistingReasoningContent() {
+        // Проверяем, что прежнее reasoning_content не теряется, а новое дописывается.
+        val c = openTag + "NEW" + closeTag
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":"$c","reasoning_content":"OLD"}}]}""",
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "split")
+        assertNotNull(result)
+        val msg = messageOf(result, 0)
+        assertEquals("OLDNEW", msg["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun splitUnclosedTagGoesToReasoning() {
+        // Проверяем, что незакрытый открывающий тег уводит хвост целиком в reasoning.
+        val c = "текст" + openTag + "мысли"
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":"$c"}}]}""",
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "split")
+        assertNotNull(result)
+        val msg = messageOf(result, 0)
+        assertEquals("текст", msg["content"]!!.jsonPrimitive.content)
+        assertEquals("мысли", msg["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun stripRemovesTagsAndLeavesNoReasoningKey() {
+        // Проверяем: в режиме strip теги и рассуждения вырезаются,
+        // а ключ reasoning_content в message отсутствует вовсе.
+        val c = "A" + openTag + "РАЗУМ" + closeTag + "B"
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":"$c"}}]}""",
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "strip")
+        assertNotNull(result)
+        val msg = messageOf(result, 0)
+        assertEquals("AB", msg["content"]!!.jsonPrimitive.content)
+        assertFalse(msg.containsKey("reasoning_content"))
+    }
+
+    @Test
+    fun missingChoicesReturnsNull() {
+        // Проверяем: без ключа choices функция не вносит изменений (null).
+        val obj = Json.parseToJsonElement(
+            """{"id":"c1","model":"m1"}""",
+        ).jsonObject
+        assertNull(transformThinkMessage(obj, "split"))
+    }
+
+    @Test
+    fun nonStringContentReturnsNull() {
+        // content = null (JsonNull) — менять нечего, функция возвращает null.
+        val nullContent = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":null}}]}""",
+        ).jsonObject
+        assertNull(transformThinkMessage(nullContent, "split"))
+
+        // content = массив частей (JsonArray) — тоже не трогаем, null.
+        val arrayContent = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":[{"type":"text","text":"hi"}]}}]}""",
+        ).jsonObject
+        assertNull(transformThinkMessage(arrayContent, "split"))
+    }
+
+    @Test
+    fun twoChoicesEachKeepOwnThinkBlock() {
+        // Проверяем, что каждый choice обрабатывается независимо: у каждого свой
+        // вырезанный content и свой reasoning_content.
+        val c0 = "А" + openTag + "А-раз" + closeTag + "Б"
+        val c1 = "В" + openTag + "В-раз" + closeTag + "Г"
+        val obj = Json.parseToJsonElement(
+            """
+            {"choices":[
+               {"index":0,"message":{"content":"$c0"},"finish_reason":"stop"},
+               {"index":1,"message":{"content":"$c1"},"finish_reason":"stop"}]}
+            """.trimIndent(),
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "split")
+        assertNotNull(result)
+        val out = Json.parseToJsonElement(result).jsonObject.get("choices")!!.jsonArray
+        val m0 = out[0].jsonObject.get("message")!!.jsonObject
+        val m1 = out[1].jsonObject.get("message")!!.jsonObject
+        assertEquals("АБ", m0["content"]!!.jsonPrimitive.content)
+        assertEquals("А-раз", m0["reasoning_content"]!!.jsonPrimitive.content)
+        assertEquals("ВГ", m1["content"]!!.jsonPrimitive.content)
+        assertEquals("В-раз", m1["reasoning_content"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun offModePassthroughKeepsTags() {
+        // Проверяем passthrough: в режиме off теги остаются в content,
+        // reasoning_content не добавляется, а результат — не null.
+        val c = "A" + openTag + "РАЗУМ" + closeTag + "B"
+        val obj = Json.parseToJsonElement(
+            """{"choices":[{"message":{"content":"$c"}}]}""",
+        ).jsonObject
+
+        val result = transformThinkMessage(obj, "off")
+        assertNotNull(result)
+        val msg = messageOf(result, 0)
+        assertEquals("A" + openTag + "РАЗУМ" + closeTag + "B", msg["content"]!!.jsonPrimitive.content)
+        assertFalse(msg.containsKey("reasoning_content"))
+    }
+}