Quarantine models after 3 bad responses until quota day ends

bot.py

@@ -605,6 +605,9 @@ from lumen_router_config import (
     _looks_like_heavy_query,
     _looks_like_freshness_query,
     _build_route,
+    _record_model_outcome,
+    _is_quarantined,
+    _quarantine_status,
 )
 # Слой ошибок живёт в lumen_errors.py (P2): здесь только реэкспорт имён.
 from lumen_errors import (
@@ -949,6 +952,9 @@ __all__ = [
     "_looks_like_heavy_query",
     "_looks_like_freshness_query",
     "_build_route",
+    "_record_model_outcome",
+    "_is_quarantined",
+    "_quarantine_status",
     "_maybe_alert_gemini_exhausted",
     "mark_state_dirty",
     "get_state",

docs/ENVIRONMENT.md

@@ -75,6 +75,7 @@ Before publishing, configure the same `LUMEN_PROXY_SECRET` on HF and every Deno
 | `DAILY_USER_GEMINI_LIMIT` | `5` | Of the above, max answers that actually went through Gemini (links, YouTube, video/audio, fresh data with search). Past it, links/YouTube/video are refused, the rest is served via Groq/OpenRouter (fresh data marked as answered without search). |
 | `DAILY_USER_TTS_LIMIT` | `5` | Max `/tts` voicings per user per day (counts toward `DAILY_USER_MESSAGE_LIMIT` too). |
 | `ROUTE_MODEL_TIMEOUT_SEC` | `22s` | Timeout for a single attempt at a single model. No retries: any failure moves straight to the next model. |
+| `MODEL_QUARANTINE_BAD_LIMIT` | `3` | How many consecutive bad responses (empty or garbled) put a model in temporary quarantine until the end of the quota day. A good response resets the counter; the last available model of a route is never quarantined. In-memory only. |
 | `ROUTE_TOTAL_BUDGET_SEC` | `40s` | Total time budget for the whole routing chain of one message, across all providers (Gemini, OpenRouter, Groq). |
 | `DRAW_TOTAL_BUDGET_SEC` | `120s` | Same idea, for the `/draw` fallback chain across image models. |
 | `CHAT_LOCK_TIMEOUT_SEC` | `45s` | How long an incoming message waits for that chat's lock before replying "busy". Deliberately shorter than `DRAW_TOTAL_BUDGET_SEC`: a second message during a long drawing gets "busy" instead of hanging. Shared by normal messages, pick-buttons and albums. |

lumen_commands.py

@@ -602,6 +602,13 @@ async def cmd_stats(message: Message) -> None:
     gemini_text = _quota_section(gemini_quota, None, bot.GEMINI_DAILY_LIMITS)
     or_text = _quota_section(bot.GLOBAL_QUOTA.get("openrouter", {}), bot.OPENROUTER_DAILY_LIMIT)
     groq_text = _quota_section(bot.GLOBAL_QUOTA.get("groq", {}), bot.GROQ_DAILY_LIMIT)
+    _quarantined_now = bot._quarantine_status()
+    if _quarantined_now:
+        quarantine_text = "\n".join(
+            f"  • {provider}/{mid}: {bad} плохих подряд (до конца суток)" for provider, mid, bad in _quarantined_now
+        )
+    else:
+        quarantine_text = "  нет"
 
     # Суточные счётчики: уникальные пользователи — только числом, без ID.
     _day_stats = bot._stats_entry()
@@ -628,6 +635,7 @@ async def cmd_stats(message: Message) -> None:
         f"<b>Gemini — запросов по моделям:</b>\n{gemini_text}\n\n"
         f"<b>OpenRouter — запросов по моделям:</b>\n{or_text}\n\n"
         f"<b>Groq — запросов по моделям:</b>\n{groq_text}\n\n"
+        f"<b>Карантин моделей:</b>\n{quarantine_text}\n\n"
         f"Вебхук: {webhook_text}\n"
         f"Память: {_process_memory_text()}\n"
         f"Хранилище: {_storage_backend_text()}"

lumen_router_config.py

@@ -7,6 +7,7 @@ lumen_router_config.py — модели и выбор маршрута (Gemini/O
 from __future__ import annotations
 
 import logging
+import os
 import re
 import time
 from dataclasses import dataclass
@@ -266,10 +267,77 @@ def _is_quota_exhausted(provider: str, model_id: str) -> bool:
         return False
 
 def _skip_exhausted(provider: str, models: list[str]) -> list[str]:
-    """Убирает модели с меткой квоты, но никогда не возвращает пустой список: один заведомо мёртвый вариант честнее мгновенного отказа (аудит 26.09.2026)."""
-    alive = [m for m in models if not _is_quota_exhausted(provider, m)]
+    """Убирает модели с меткой квоты и временным карантином, но никогда не возвращает пустой список: один заведомо мёртвый вариант честнее мгновенного отказа (аудит 26.09.2026)."""
+    alive = [m for m in models if not _is_quota_exhausted(provider, m) and not _is_quarantined(provider, m)]
     return alive or list(models)
 
+# ── Временный карантин моделей ──
+# Только в памяти: N плохих ответов подряд (пусто или mush-каша) — и роутер
+# пропускает модель до конца суток квоты. Реестр _OR_MODEL_HEALTH не трогаем:
+# туда только датированные доказательства.
+_QUARANTINE: dict[tuple[str, str], dict[str, Any]] = {}
+
+def _quarantine_threshold() -> int:
+    """Сколько плохих подряд до карантина (MODEL_QUARANTINE_BAD_LIMIT, дефолт 3)."""
+    try:
+        raw = (os.getenv("MODEL_QUARANTINE_BAD_LIMIT", "") or "").strip()
+        value = int(raw) if raw else 3
+    except (TypeError, ValueError):
+        return 3
+    return max(1, value)
+
+def _quarantine_entry(provider: str, model_id: str) -> dict[str, Any]:
+    """Сегодняшняя запись счётчика: смена суток квоты обнуляет молча."""
+    import bot
+    today = bot._current_quota_day()
+    key = (provider, model_id)
+    entry = _QUARANTINE.get(key)
+    if entry is None or entry.get("day") != today:
+        entry = {"bad": 0, "day": today}
+        _QUARANTINE[key] = entry
+    return entry
+
+def _record_model_outcome(provider: str, model_id: str, *, bad: bool) -> None:
+    """Плохой ответ +1 к счётчику (на пороге — карантин с записью в лог),
+    успешный — сбрасывает счётчик."""
+    if not bad:
+        if _QUARANTINE.pop((provider, model_id), None) is not None:
+            log.debug("[quarantine] %s/%s answered well, counter reset.", provider, model_id)
+        return
+    entry = _quarantine_entry(provider, model_id)
+    entry["bad"] = int(entry.get("bad") or 0) + 1
+    if entry["bad"] == _quarantine_threshold():
+        log.warning(
+            "[quarantine] %s/%s quarantined until end of quota day %s after %d consecutive bad responses (empty or garbled).",
+            provider, model_id, entry["day"], entry["bad"],
+        )
+
+def _is_quarantined(provider: str, model_id: str) -> bool:
+    try:
+        import bot
+        entry = _QUARANTINE.get((provider, model_id))
+        return bool(entry and entry.get("day") == bot._current_quota_day()
+                    and int(entry.get("bad") or 0) >= _quarantine_threshold())
+    except Exception as exc:
+        # Тот же fail-open, что у _is_quota_exhausted: битое состояние не должно
+        # молча выкидывать живые модели из маршрута.
+        log.warning("[router] Quarantine state unreadable, treating %s/%s as available: %s", provider, model_id, exc)
+        return False
+
+def _quarantine_status() -> list[tuple[str, str, int]]:
+    """Кто сейчас в карантине: для /stats. Пустые и вчерашние записи не показываем."""
+    try:
+        import bot
+        today = bot._current_quota_day()
+        threshold = _quarantine_threshold()
+        return sorted(
+            (provider, model_id, int(entry.get("bad") or 0))
+            for (provider, model_id), entry in _QUARANTINE.items()
+            if entry.get("day") == today and int(entry.get("bad") or 0) >= threshold
+        )
+    except Exception:
+        return []
+
 def _or_route(models: list[str]) -> list[tuple[str, str]]:
     """Список ID в пары (provider, model_id), минус реестр исключённых и модели с исчерпанной квотой."""
     return [("openrouter", m) for m in _skip_exhausted("openrouter", models) if m not in _ROUTER_EXCLUDED_OR_MODELS]

lumen_routes.py

@@ -35,7 +35,7 @@ from lumen_router_config import (
     GEMINI_DEFAULT_CHAIN,
     _looks_like_heavy_query,
 )
-from lumen_security import _scrub_identity_leak
+from lumen_security import _scrub_identity_leak, _detect_garbled_mix
 
 # Транскрипт длинного войса режем сверху — иначе маршрут ниже упрётся в лимиты моделей.
 _TRANSCRIPT_MAX_CHARS = 4000
@@ -254,9 +254,13 @@ async def _chat_completion_chain(
             answer = answer.strip()
             if not answer:
                 # Пустой ответ — повод попробовать следующую модель (прод 17.09.2026: юзер дважды увидел "Empty response").
+                bot._record_model_outcome(provider, model_trial, bad=True)
                 raise RuntimeError(f"Model {model_trial} returned an empty response")
 
             answer = _scrub_identity_leak(answer, source=f"{provider}_chat_completion:{model_trial}")
+            # Каша-каша тоже считается плохим (доставляется как есть, как раньше),
+            # успех сбрасывает счётчик карантина.
+            bot._record_model_outcome(provider, model_trial, bad=_detect_garbled_mix(answer))
             log.info('[%s] Successful response from model %s (primary=%s, models tried: %d)', label, model_trial, primary_model_id, len(tried))
             _pt, _ct, _tt = _usage_from_openai_response(resp)
             _log_llm_usage(chat_id=chat_id, provider=provider, model_id=model_trial,
@@ -777,6 +781,7 @@ async def ask_gemini(
             ans = ans.strip()
             if not ans:
                 # Пустой ответ — пробуем следующую модель (прод 17.09.2026: юзер увидел буквальное "Empty response").
+                bot._record_model_outcome("gemini", curr_model_id, bad=True)
                 raise RuntimeError(f"Model {curr_model_id} returned an empty response")
             break
         except (asyncio.TimeoutError, asyncio.CancelledError) as exc:
@@ -833,6 +838,7 @@ async def ask_gemini(
     _record_model_latency(_model_speed_key("gemini", curr_model_id), total_sec=time.monotonic() - attempt_start)
 
     ans = _scrub_identity_leak(ans, source=f"ask_gemini:{curr_model_id}")
+    bot._record_model_outcome("gemini", curr_model_id, bad=_detect_garbled_mix(ans))
 
     hist.append({"role": "user", "content": _history_user_text(user_text)})
     hist.append({"role": "assistant", "content": ans})

lumen_streaming.py

@@ -27,6 +27,7 @@ from lumen_security import (
     _IDENTITY_LEAK_FALLBACK,
     _INJECTED_PAYLOAD_ECHO_FALLBACK,
     _detect_injected_payload_echo,
+    _detect_garbled_mix,
     _detect_identity_leak,
     _scrub_identity_leak,
 )
@@ -429,6 +430,7 @@ async def _run_streaming_reply(
 
     # Пустой full_text сюда не доходит — ветки "Empty response" нет.
     final_answer = _scrub_identity_leak(full_text.strip(), source=f"{provider}_stream_final:{model_id}")
+    bot._record_model_outcome(provider, model_id, bad=_detect_garbled_mix(full_text.strip()))
     hist.append({"role": "user", "content": _history_user_text(user_text)})
     hist.append({"role": "assistant", "content": final_answer})
     # Тот же _trim_history, что в нестриминговых путях (см. комментарий выше).

tests/conftest.py

@@ -24,12 +24,16 @@ from unittest.mock import AsyncMock
 
 import bot
 import lumen_limits
+import lumen_router_config
 
 
 @pytest.fixture(autouse=True)
 def _bot_global_state_guard():
     """Снимок наиболее часто вручную сохраняемых модульных глобалов bot.py перед
     каждым тестом и восстановление после (аудит техдолга, август 2026).
+    Карантин моделей (lumen_router_config._QUARANTINE) тоже снимается: пустые
+    ответы в тестах честно пишут в счётчик, без сброса один и тот же фейковый
+    ID за три теста ушёл бы в карантин и начал фильтровать маршруты.
 
     Десятки тестов в test_bot_*.py вручную сохраняли/восстанавливали
     bot.chat_state/bot.GLOBAL_QUOTA/bot.client/bot.bot в try/finally — рабочий, но
@@ -48,6 +52,7 @@ def _bot_global_state_guard():
     import bot as _bot_module
     chat_state_snapshot = copy.deepcopy(_bot_module.chat_state)
     quota_snapshot = copy.deepcopy(_bot_module.GLOBAL_QUOTA)
+    quarantine_snapshot = copy.deepcopy(lumen_router_config._QUARANTINE)
     client_snapshot = _bot_module.client
     bot_snapshot = _bot_module.bot
     yield
@@ -55,6 +60,8 @@ def _bot_global_state_guard():
     _bot_module.chat_state.update(chat_state_snapshot)
     _bot_module.GLOBAL_QUOTA.clear()
     _bot_module.GLOBAL_QUOTA.update(quota_snapshot)
+    lumen_router_config._QUARANTINE.clear()
+    lumen_router_config._QUARANTINE.update(quarantine_snapshot)
     _bot_module.client = client_snapshot
     _bot_module.bot = bot_snapshot
 

tests/test_bot_commands.py

@@ -1426,3 +1426,22 @@ def test_selftest_llm_head_openrouter_error_returns_false_without_quota(monkeypa
     assert ok is False and "boom-429" in detail and elapsed >= 0
     after = ((bot.GLOBAL_QUOTA.get("openrouter") or {}).get(head) or {}).get("used") or 0
     assert after == before
+
+
+def test_cmd_stats_shows_quarantine(monkeypatch):
+    # Карантин виден владельцу в /stats: иначе объезд модели выглядел бы магией.
+    monkeypatch.setattr(bot, "OWNER_ID", 888001)
+    for _ in range(3):
+        bot._record_model_outcome("openrouter", "qs-model:free", bad=True)
+    incoming = _FakeIncomingMessage(999707)
+    incoming.from_user = SimpleNamespace(id=888001)
+    sent = {}
+
+    async def fake_tg_call(method, *args, **kwargs):
+        sent["text"] = args[0] if args else kwargs.get("text", "")
+        return SimpleNamespace()
+
+    monkeypatch.setattr(bot, "_tg_call", fake_tg_call)
+    asyncio.run(bot.cmd_stats(incoming))
+    assert "Карантин моделей" in sent["text"]
+    assert "qs-model:free" in sent["text"]

tests/test_bot_routes.py

@@ -457,6 +457,43 @@ def test_or_empty_response_falls_through_to_next_model(monkeypatch):
     assert calls == ["m1:free", "m2:free"]
 
 
+def test_chain_empty_responses_feed_quarantine_counter(monkeypatch):
+    # Три пустых подряд в одну голову — карантин (реальная регрессия: мёртвая голова
+    # жевала бы каждую попытку до конца суток вместо объезда после третьей).
+    async def fake_empty(path, method="GET", *, json_body=None, deadline=None):
+        return {"choices": []}
+
+    monkeypatch.setattr(bot, "_or_request", fake_empty)
+    messages = [
+        {"role": "system", "content": "sys"},
+        {"role": "user", "content": "hi"},
+    ]
+    for _ in range(3):
+        with pytest.raises(RuntimeError, match="empty response"):
+            asyncio.run(bot._or_chat_completion_with_fallback(messages, ["qe:free"], "qe:free"))
+    assert bot._is_quarantined("openrouter", "qe:free") is True
+
+
+def test_chain_garbled_response_delivered_but_feeds_quarantine(monkeypatch):
+    # Каша доставляется как раньше (без подмены), но в счётчик идёт: три таких —
+    # и голова в карантине.
+    mush = "результат: " + "dataданные fileфайл testтест " + "продолжение " + "я" * 80
+    assert len(mush) >= 100
+
+    async def fake_mush(path, method="GET", *, json_body=None, deadline=None):
+        return {"choices": [{"message": {"content": mush}}]}
+
+    monkeypatch.setattr(bot, "_or_request", fake_mush)
+    messages = [
+        {"role": "system", "content": "sys"},
+        {"role": "user", "content": "hi"},
+    ]
+    for _ in range(3):
+        answer, used = asyncio.run(bot._or_chat_completion_with_fallback(messages, ["qm:free"], "qm:free"))
+        assert (answer, used) == (mush, "qm:free")
+    assert bot._is_quarantined("openrouter", "qm:free") is True
+
+
 def test_attempt_timeout_caps_by_remaining_route_budget():
     # Регрессия (аудит 26.09.2026): каждая попытка ждала полные ROUTE_MODEL_TIMEOUT_SEC,
     # поэтому маршрут держал лок чата до 40+22с вместо заявленных 40с.

tests/test_lumen_router_config.py

@@ -729,3 +729,52 @@ def test_quota_exhausted_logs_broken_state_loudly(monkeypatch, caplog):
     with caplog.at_level("WARNING", logger="bot"):
         assert lumen_router_config._is_quota_exhausted("openrouter", "m") is False
     assert "Quota state unreadable" in caplog.text
+
+
+def test_quarantine_triggers_after_three_consecutive_bad_and_skips_model(caplog):
+    # Три плохих подряд — карантин до конца суток: роутер объезжает модель.
+    import bot
+    with caplog.at_level("WARNING", logger="bot"):
+        for _ in range(3):
+            bot._record_model_outcome("openrouter", "q-model:free", bad=True)
+    assert bot._is_quarantined("openrouter", "q-model:free") is True
+    assert "[quarantine]" in caplog.text
+    assert bot._quarantine_status() == [("openrouter", "q-model:free", 3)]
+    from lumen_router_config import _OR_LIGHT_ORDER
+    route = [m for m in _OR_LIGHT_ORDER if m != "q-model:free"] + ["q-model:free"]
+    assert "q-model:free" not in lumen_router_config._skip_exhausted("openrouter", route)
+
+
+def test_quarantine_never_empties_route_and_success_resets(caplog):
+    # Последняя доступная модель не карантинится де-факто: пустой маршрут не возвращаем.
+    import bot
+    for _ in range(5):
+        bot._record_model_outcome("groq", "only-model", bad=True)
+    assert bot._is_quarantined("groq", "only-model") is True
+    assert lumen_router_config._skip_exhausted("groq", ["only-model"]) == ["only-model"]
+    bot._record_model_outcome("groq", "only-model", bad=False)
+    assert bot._is_quarantined("groq", "only-model") is False
+    assert bot._quarantine_status() == []
+
+
+def test_quarantine_resets_on_quota_day_change(monkeypatch):
+    # Карантин только до конца суток квоты: новый день — чистый счётчик.
+    import bot
+    monkeypatch.setattr(bot, "_current_quota_day", lambda: "2099-01-01")
+    for _ in range(3):
+        bot._record_model_outcome("openrouter", "day-model:free", bad=True)
+    assert bot._is_quarantined("openrouter", "day-model:free") is True
+    monkeypatch.setattr(bot, "_current_quota_day", lambda: "2099-01-02")
+    assert bot._is_quarantined("openrouter", "day-model:free") is False
+    assert bot._quarantine_status() == []
+
+
+def test_quarantine_threshold_reads_env(monkeypatch):
+    # N из env: при 2 карантин наступает раньше (дефолт 3 проверен выше).
+    import bot
+    monkeypatch.setenv("MODEL_QUARANTINE_BAD_LIMIT", "2")
+    assert lumen_router_config._quarantine_threshold() == 2
+    bot._record_model_outcome("openrouter", "env-model:free", bad=True)
+    assert bot._is_quarantined("openrouter", "env-model:free") is False
+    bot._record_model_outcome("openrouter", "env-model:free", bad=True)
+    assert bot._is_quarantined("openrouter", "env-model:free") is True