Run routes as consecutive provider blocks and keep Gemma out of the Gemini daily limit

Grouping by provider glued the Gemini fallback chain ahead of Groq and burned the route budget; sorting moved Gemma off the head. Blocked Gemini answers now return empty so the chain moves on.

lumen_model_speed.py

@@ -68,16 +68,18 @@ def first_chunk_limit_sec(key: str, floor_sec: float) -> float:
 
 
 def reorder_route(route: list[tuple[str, str]]) -> list[tuple[str, str]]:
-    """Переупорядочить маршрут по задержкам, не ломая архитектуру: блоки провайдеров на месте, внутри блока — по ожидаемому времени. Сортировка стабильная, новички сохраняют кураторский порядок."""
-    blocks: list[list[tuple[str, str]]] = []
-    block_index: dict[str, int] = {}
-    for item in route:
-        provider = item[0]
-        if provider not in block_index:
-            block_index[provider] = len(blocks)
-            blocks.append([])
-        blocks[block_index[provider]].append(item)
+    """Переставить модели по задержкам внутри подряд идущего блока одного провайдера.
+
+    Склейка блоков по провайдеру уводила резервную Gemini-цепочку вперёд Groq
+    (аудит 27.10.2026); порядок блоков — часть защиты квот, поэтому не трогаем его.
+    """
     ordered: list[tuple[str, str]] = []
-    for block in blocks:
-        ordered.extend(sorted(block, key=lambda item: expected_total_sec(speed_key(item[0], item[1]))))
+    run: list[tuple[str, str]] = []
+    for item in route:
+        if run and item[0] != run[-1][0]:
+            ordered.extend(sorted(run, key=lambda i: expected_total_sec(speed_key(i[0], i[1]))))
+            run = []
+        run.append(item)
+    if run:
+        ordered.extend(sorted(run, key=lambda i: expected_total_sec(speed_key(i[0], i[1]))))
     return ordered

lumen_routes.py

@@ -30,6 +30,7 @@ from lumen_model_speed import (
 )
 from lumen_router_config import (
     GEMINI_MODELS,
+    _GEMMA_TEXT_CHAIN,
     _OR_LIGHT_ORDER,
     _OR_HEAVY_ORDER,
     _OR_VISION_ORDER,
@@ -752,7 +753,6 @@ async def _extract_gemini_answer_text(resp: Any, *, model_id: str, call_contents
                          except Exception:
                              tool_calls.append("response")
         if not ans and (tool_calls or reasons):
-            retry_failed = False
             if tool_calls or any("MALFORMED_FUNCTION_CALL" in r for r in reasons):
                 # Ответ без текста: битый вызов или голый tool_call — пользователю
                 # JSON инструментов не показываем (прод 07.10.2026), повторяем без них.
@@ -778,24 +778,19 @@ async def _extract_gemini_answer_text(resp: Any, *, model_id: str, call_contents
                         log.warning("[gemini] Model %s had MALFORMED_FUNCTION_CALL, retried without tools successfully.", model_id)
                     elif retry_resp is not None:
                         # Повтор прошёл, но вернул пусто без исчерпания бюджета:
-                        # это повод на следующую модель, а не заглушка успеха.
-                        retry_failed = True
+                        # это повод на следующую модель.
                         log.warning("[gemini] Retry after MALFORMED_FUNCTION_CALL returned empty text, trying the next model.")
                     elif deadline is not None and deadline - time.monotonic() <= 0:
-                        # Повтор не успел уложиться в бюджет маршрута. Возвращаем ПУСТОЙ
-                        # ответ, чтобы ask_gemini ушёл на следующую модель, а не подсунул
-                        # пользователю "[Ответ заблокирован...]" (враждебное ревью 27.09.2026):
-                        # раньше повтор выполнялся почти всегда, и эта ветка не всплывала.
-                        retry_failed = True
+                        # Повтор не успел уложиться в бюджет маршрута: отдаём пусто,
+                        # ask_gemini перейдёт к следующей модели.
                         log.warning("[gemini] Retry after MALFORMED_FUNCTION_CALL skipped: route budget is exhausted, trying the next model.")
                 except Exception as retry_exc:
                     log.warning("[gemini] Retry without tools after MALFORMED_FUNCTION_CALL also failed: %s", retry_exc)
-                    # Повтор упал — тоже отдаём пусто: маршрут должен уйти на следующую
-                    # модель, а не показывать заглушку блокировки как готовый ответ
-                    # (иначе цепочка останавливалась на первой же битой модели).
-                    retry_failed = True
-            if not ans and not retry_failed and reasons:
-                ans = f"[Ответ заблокирован или пуст. Причина: {', '.join(reasons)}]"
+                    # Повтор упал — отдаём пусто: маршрут уйдёт к следующей модели,
+                    # а не остановится на первой же битой.
+            # Блокировка (SAFETY/RECITATION) — не ответ: пустая строка двигает цепочку
+            # дальше, а локализованный отказ пользователь увидит, только если не ответил
+            # никто (аудит 27.10.2026: русская заглушка останавливала маршрут).
     # Пустая строка без блокировки — не "Empty response": ask_gemini пробует следующую модель.
     return ans.strip()
 
@@ -1014,16 +1009,23 @@ async def _run_route(
         # Снаружи дедлайн приходит с транскрибацией: она уже потратила часть бюджета.
         deadline = time.monotonic() + bot.ROUTE_TOTAL_BUDGET_SEC
 
-    groups: dict[str, list[str]] = {"gemini": [], "openrouter": [], "groq": []}
+    # Блоки идут ПОДРЯД, как собраны: Gemma → Groq → OpenRouter → Gemini-резерв.
+    # Склейка по провайдеру ставила 11 Gemini-моделей впереди Groq и съедала
+    # 40-секундный бюджет до первого независимого провайдера (аудит 27.10.2026).
+    runs: list[tuple[str, list[str]]] = []
     for provider, model_id in route:
-        groups.setdefault(provider, []).append(model_id)
+        if runs and runs[-1][0] == provider:
+            runs[-1][1].append(model_id)
+        else:
+            runs.append((provider, [model_id]))
     first_provider = route[0][0]
-    # Порядок провайдеров — по первому появлению в маршруте (для прежних двухпровайдерных маршрутов то же самое: голова + второй).
-    provider_order = list(dict.fromkeys(p for p, _ in route))
 
     # Учёт дневных лимитов пользователя — только дошедшие до модели ответы.
-    def _count_user_answer(provider_name: str) -> None:
-        bot._record_user_daily(bot._user_key_for_message(message), gemini=(provider_name == "gemini"))
+    # Gemma не в счёт: у неё отдельная большая квота, иначе 5 обычных сообщений
+    # запирали голос/видео на день (аудит 27.10.2026).
+    def _count_user_answer(provider_name: str, model_id: str | None = None) -> None:
+        counts_gemini = provider_name == "gemini" and (model_id or "") not in _GEMMA_TEXT_CHAIN
+        bot._record_user_daily(bot._user_key_for_message(message), gemini=counts_gemini)
         bot._record_stats_event("answers_sent")
 
     # Кто фактически ответил (прод 12.10.2026): для пост-проверки живого поиска.
@@ -1041,7 +1043,7 @@ async def _run_route(
             streamed, placeholder = await bot._try_gemini_streaming(chat_id, ai_prompt, message, head_model, deadline=deadline)
             if streamed is not None:
                 log.info('[router] chat=%s response received via streaming (gemini:%s)', chat_id, head_model)
-                _count_user_answer("gemini")
+                _count_user_answer("gemini", head_model)
                 _note_answered("gemini", head_model)
                 return streamed, True
             tried_stream_model, tried_stream_provider = head_model, "gemini"
@@ -1068,8 +1070,8 @@ async def _run_route(
     is_video_or_audio = bool(media) and any(not (m[1] or "").startswith("image/") for m in media)
     last_exc: Exception | None = None
     media_note_added = False
-    for provider in provider_order:
-        ids = list(groups.get(provider) or [])
+    for run_index, (provider, run_ids) in enumerate(runs):
+        ids = list(run_ids)
         if provider == tried_stream_provider and tried_stream_model in ids:
             ids = [m for m in ids if m != tried_stream_model]
         if not ids:
@@ -1101,9 +1103,9 @@ async def _run_route(
                     await bot._delete_message_quietly(reusable_placeholder)
                 reusable_placeholder = None
                 if reused:
-                    _count_user_answer(provider)
+                    _count_user_answer(provider, (provenance or {}).get("model"))
                     return ans, True
-            _count_user_answer(provider)
+            _count_user_answer(provider, (provenance or {}).get("model"))
             return ans, False
         except asyncio.CancelledError:
             # Отмена посреди ответа: плейсхолдер чистим, отмену пробрасываем —
@@ -1124,11 +1126,7 @@ async def _run_route(
                 media_note_added = True
             log.warning('[router] Provider %s failed completely (%s), trying the next one on the route, if any.', provider, exc)
             # Суточный счётчик /stats: дальше по маршруту есть кому ответить.
-            try:
-                _left = provider_order.index(provider) + 1
-            except ValueError:
-                _left = len(provider_order)
-            if any(groups.get(_p) for _p in provider_order[_left:]):
+            if any(ids for _, ids in runs[run_index + 1:]):
                 bot._record_stats_event("fallbacks")
 
     if reusable_placeholder is not None:

tests/test_bot_routes.py

@@ -366,14 +366,14 @@ def test_extract_gemini_answer_skips_retry_when_route_budget_spent():
         bot.client = original_client
 
 
-def test_extract_gemini_answer_reports_non_malformed_block_without_retry_state():    # Пустой ответ с причиной без MALFORMED_FUNCTION_CALL не должен падать из-за
-    # неинициализированного флага пропуска ретрая. Раньше правка оставляла переменную
-    # только внутри MALFORMED-ветки и такой ответ давал UnboundLocalError.
+def test_extract_gemini_answer_returns_empty_for_blocked_response():
+    # Блокировка (SAFETY) — не ответ: пустая строка двигает цепочку дальше,
+    # а не подсовывает пользователю русскую техническую заглушку (аудит 27.10.2026).
     resp = _FakeGeminiResponse(text="", candidates=[_FakeCandidate(finish_reason="SAFETY")])
     ans = asyncio.run(bot._extract_gemini_answer_text(
         resp, model_id="gemini-3.8-flash", call_contents=[], gconfig=None,
     ))
-    assert "SAFETY" in ans
+    assert ans == ""
 
 
 def test_extract_gemini_answer_retries_without_tools_on_tool_only_response():
@@ -1874,6 +1874,81 @@ def test_run_route_failure_records_no_user_daily():
         bot.chat_state.pop(chat_id, None)
 
 
+def test_run_route_keeps_route_block_order(monkeypatch):
+    # Что защищает: маршрут исполняется блоками в том порядке, как собран
+    # (Gemma → Groq → OpenRouter → Gemini-резерв). Регрессия: склейка блоков по
+    # провайдеру отправляла Gemma одним вызовом со всей Gemini-цепочкой и съедала
+    # бюджет до первого независимого провайдера (аудит 27.10.2026).
+    calls = []
+
+    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None,
+                              deadline=None, provenance=None):
+        calls.append(("gemini", list(model_chain)))
+        if model_chain == ["gemini-3.8-flash"]:
+            if provenance is not None:
+                provenance.update(provider="gemini", model="gemini-3.8-flash")
+            return "резерв Gemini"
+        raise RuntimeError("gemma недоступна")
+
+    async def failing_groq(cid, prompt, model_chain, deadline=None):
+        calls.append(("groq", list(model_chain)))
+        raise bot.GroqAPIError("overloaded", status_code=503)
+
+    async def failing_or(cid, prompt, model_chain, deadline=None):
+        calls.append(("openrouter", list(model_chain)))
+        raise bot.OpenRouterAPIError("сломано", status_code=500)
+
+    monkeypatch.setattr(bot, "ask_gemini", fake_ask_gemini)
+    monkeypatch.setattr(bot, "ask_groq_text", failing_groq)
+    monkeypatch.setattr(bot, "ask_openrouter_text", failing_or)
+    route = [
+        ("gemini", "gemma-4-26b-a4b-it"),
+        ("groq", "qwen/qwen3.8-27b"),
+        ("openrouter", "liquid/lfm-2.5-2.6b:free"),
+        ("gemini", "gemini-3.8-flash"),
+    ]
+    ans, sent = asyncio.run(bot._run_route(999310, "привет", route, message=None, allow_stream=False))
+    assert ans == "резерв Gemini" and sent is False
+    assert calls == [
+        ("gemini", ["gemma-4-26b-a4b-it"]),
+        ("groq", ["qwen/qwen3.8-27b"]),
+        ("openrouter", ["liquid/lfm-2.5-2.6b:free"]),
+        ("gemini", ["gemini-3.8-flash"]),
+    ]
+
+
+def test_run_route_gemma_answer_does_not_spend_gemini_user_limit():
+    # Что защищает: дневной лимит Gemini у пользователя. Регрессия: ответ Gemma
+    # считался как Gemini, и несколько обычных сообщений запирали голос/видео
+    # на сутки (аудит 27.10.2026). Модель берётся из provenance, как в проде.
+    from types import SimpleNamespace
+    chat_id = 999311
+    incoming = _FakeIncomingMessage(chat_id)
+    incoming.from_user = SimpleNamespace(id=777013)
+
+    async def fake_ask_gemini(cid, prompt, media=None, youtube_url=None, model_chain=None,
+                              deadline=None, provenance=None):
+        if provenance is not None:
+            provenance.update(provider="gemini", model="gemma-4-26b-a4b-it")
+        return "Ответ Gemma"
+
+    original = bot.ask_gemini
+    bot.ask_gemini = fake_ask_gemini
+    try:
+        ans, _ = asyncio.run(bot._run_route(
+            chat_id, "привет", [("gemini", "gemma-4-26b-a4b-it")], incoming,
+            allow_stream=False, provenance={},
+        ))
+        assert ans == "Ответ Gemma"
+        entry = bot.GLOBAL_QUOTA.get("user_daily", {}).get("777013")
+        assert entry is not None
+        assert entry["total"] == 1 and entry["gemini"] == 0
+    finally:
+        bot.ask_gemini = original
+        bot.GLOBAL_QUOTA.get("user_daily", {}).pop("777013", None)
+        bot.chat_state.pop(chat_id, None)
+
+
 def test_handled_message_grows_provider_quota_user_daily_and_stats(rate_guard_setup, monkeypatch):
     # Что защищает: воронку учёта после обработанного сообщения (квота
     # провайдера + user_daily + суточные счётчики /stats одним проходом).

tests/test_lumen_model_speed.py

@@ -71,7 +71,7 @@ def test_first_chunk_limit_respects_floor_and_adapts():
     assert lumen_model_speed.first_chunk_limit_sec(slow, 12.0) == 75.0
 
 
-def test_reorder_route_sorts_within_provider_blocks_only():
+def test_reorder_route_sorts_within_consecutive_runs_only():
     _reset()
     slow = ("openrouter", "slow:free")
     fast = ("openrouter", "fast:free")
@@ -79,8 +79,10 @@ def test_reorder_route_sorts_within_provider_blocks_only():
     lumen_model_speed.record_response(lumen_model_speed.speed_key(*fast), total_sec=5.0)
     route = [slow, ("gemini", "gemini-3.8-flash"), fast, ("openrouter", "openrouter/free")]
     reordered = lumen_model_speed.reorder_route(route)
+    # Блоки не склеиваются по провайдеру: медленная голова не переезжает через
+    # Gemini, порядок блоков остаётся кураторским (аудит 27.10.2026).
     assert [m for _, m in reordered] == [
-        "fast:free", "openrouter/free", "slow:free", "gemini-3.8-flash",
+        "slow:free", "gemini-3.8-flash", "fast:free", "openrouter/free",
     ]