Trim Groq prompt history to token budget to stop HTTP 413s

lumen_routes.py

@@ -243,6 +243,7 @@ async def _chat_completion_chain(
             log.warning('[%s] Route time budget exhausted before model %s. Tried: %s', label, model_trial, ", ".join(tried) or "none")
             raise bot.RouteBudgetExceededError(tried)
         tried.append(model_trial)
+        bot._record_stats_event("model_attempts")
         messages[0]["content"] = bot.get_system_prompt(model_trial)
         attempt_start = time.monotonic()
         try:
@@ -274,6 +275,7 @@ async def _chat_completion_chain(
             raise
         except Exception as exc:
             last_exc = exc
+            bot._record_stats_event("model_failures")
             if stop_on is not None and stop_on(exc):
                 log.warning(
                     '[%s] Model %s failed with an account-wide limit — stopping the chain, the rest would fail the same way.',
@@ -344,8 +346,42 @@ async def ask_openrouter_text(chat_id: int, user_text: str, model_chain: list[st
     bot._record_quota_usage("openrouter", model_trial)
     return answer
 
+# Groq free отдаёт HTTP 413, когда запрос целиком превышает ~7K токенов
+# (прод 05–07.10.2026: история 9–27K токенов — каждая попытка в длинном чате
+# падала, Groq там мёртв принципиально). Системный промпт (~4.5K токенов) уже
+# съедает больше половины, поэтому историю под Groq режем отдельно — остальным
+# провайдерам она по-прежнему едет целиком. Оценка грубая: ASCII ~4 символа на
+# токен, кириллица ~2; бюджет 6K с запасом под погрешность оценки.
+_GROQ_PROMPT_TOKEN_BUDGET = 6000
+
+def _estimate_tokens(text: str) -> int:
+    """Грубая оценка токенов без токенизатора: хватает, чтобы не упереться в лимит."""
+    if not isinstance(text, str) or not text:
+        return 0
+    ascii_chars = sum(1 for c in text if ord(c) < 128)
+    return ascii_chars // 4 + (len(text) - ascii_chars) // 2
+
+def _trim_messages_for_groq(messages: list[dict]) -> list[dict]:
+    """История под лимит Groq: системный промпт и текущий вопрос неприкосновенны,
+    из середины выкидываем самые старые, пока влезаем в бюджет. Хранимую историю
+    не трогаем — режется только копия под этот запрос."""
+    if not messages:
+        return messages
+    sizes = [_estimate_tokens(m.get("content") if isinstance(m.get("content"), str) else str(m.get("content") or "")) for m in messages]
+    if sum(sizes) <= _GROQ_PROMPT_TOKEN_BUDGET:
+        return messages
+    head, middle, tail = messages[0], messages[1:-1], messages[-1]
+    budget_left = _GROQ_PROMPT_TOKEN_BUDGET - sizes[0] - (sizes[-1] if len(messages) > 1 else 0)
+    kept: list[dict] = []
+    for m, s in zip(reversed(middle), reversed(sizes[1:-1])):
+        if s <= budget_left:
+            kept.append(m)
+            budget_left -= s
+    kept.reverse()
+    return [head] + kept + ([tail] if len(messages) > 1 else [])
+
 async def ask_groq_text(chat_id: int, user_text: str, model_chain: list[str], *, deadline: float | None = None) -> str:
-    """Обычный текстовый запрос через прямой Groq — по образцу ask_openrouter_text: одна попытка на модель, скраб утечек, расход в квоту "groq". Сообщения строит общий _build_openrouter_turn_messages (тот же OpenAI-формат)."""
+    """Обычный текстовый запрос через прямой Groq — по образцу ask_openrouter_text: одна попытка на модель, скраб утечек, расход в квоту "groq". Сообщения строит общий _build_openrouter_turn_messages (тот же OpenAI-формат). Историю под запрос режет _trim_messages_for_groq (иначе см. его комментарий)."""
     import bot
     from lumen_router_config import _GROQ_LIGHT_ORDER
     state = bot.get_state(chat_id)
@@ -355,6 +391,7 @@ async def ask_groq_text(chat_id: int, user_text: str, model_chain: list[str], *,
     trial_models = list(dict.fromkeys(model_chain)) or [_GROQ_LIGHT_ORDER[0]]
     primary_model_id = trial_models[0]
     messages = bot._build_openrouter_turn_messages(chat_id, user_text, primary_model_id)
+    messages = _trim_messages_for_groq(messages)
 
     async def _request(payload: dict, dl: float | None):
         return await bot._groq_request("chat/completions", "POST", json_body=payload, deadline=dl)
@@ -788,6 +825,7 @@ async def ask_gemini(
             log.warning('[gemini] Route time budget exhausted. Tried: %s', ", ".join(sorted(tried_models)) or "none")
             raise bot.RouteBudgetExceededError(sorted(tried_models))
         tried_models.add(curr_model_id)
+        bot._record_stats_event("model_attempts")
         call_contents, gconfig = bot._build_gemini_call_config(curr_model_id, contents)
 
         attempt_start = time.monotonic()
@@ -810,9 +848,11 @@ async def ask_gemini(
                 raise
             next_model = bot._next_fallback_model(tried_models, chain)
             if next_model:
+                bot._record_stats_event("model_failures")
                 log.warning("[gemini] Model %s timed out (%.0fs). Switching to %s", curr_model_id, bot.ROUTE_MODEL_TIMEOUT_SEC, next_model)
                 curr_model_id = next_model
                 continue
+            bot._record_stats_event("model_failures")
             log.warning("[gemini] Model %s timed out and no fallback models remain in route.", curr_model_id)
             raise
         except Exception as exc:
@@ -834,6 +874,7 @@ async def ask_gemini(
                     bot._mark_rate_limited("gemini", curr_model_id)
                 next_model = bot._next_fallback_model(tried_models, chain)
                 if next_model:
+                    bot._record_stats_event("model_failures")
                     log.warning("[gemini] Model %s quota exhausted (429). Switching to %s", curr_model_id, next_model)
                     curr_model_id = next_model
                     continue
@@ -848,10 +889,12 @@ async def ask_gemini(
             # Остальные исходы — одна попытка и сразу следующая модель, без ретраев.
             next_model = bot._next_fallback_model(tried_models, chain)
             if next_model:
+                bot._record_stats_event("model_failures")
                 reason = f"{kind}/{status_code}" if status_code else f"{kind}/{exc_class}"
                 log.warning("[gemini] Model %s failed (%s). Switching to %s", curr_model_id, reason, next_model)
                 curr_model_id = next_model
                 continue
+            bot._record_stats_event("model_failures")
             log.warning("[gemini] Model %s failed (%s) and no fallback models remain in route.", curr_model_id, exc_class)
             raise
 

lumen_streaming.py

@@ -248,6 +248,9 @@ async def _run_streaming_reply(
         if placeholder is None:
             return None, None
         sent_messages.append(placeholder)
+        # Попытка к модели состоялась (запрос уже ушёл в генератор кусков);
+        # пустой считают только ранний обрыв до показа — частичный ответ показан.
+        bot._record_stats_event("model_attempts")
 
         # Дальше цикл читает генератор напрямую — проверки кусков/утечек/троттлинга ниже без изменений.
         piece_agen = _pieces_with_waiting_feedback(
@@ -404,6 +407,7 @@ async def _run_streaming_reply(
                 pass
             # Плейсхолдер НЕ удаляем — возвращаем для переиспользования (см. докстринг).
             log.warning('[stream] Stream %s/%s failed before showing any content, falling back to a regular call: %s', provider, model_id, exc)
+            bot._record_stats_event("model_failures")
             return None, (sent_messages[-1] if sent_messages else None)
         log.warning('[stream] Stream %s/%s failed after partially showing the response, finishing as-is: %s', provider, model_id, exc)
         if _detect_identity_leak(full_text):
@@ -465,9 +469,10 @@ async def _try_openrouter_streaming(chat_id: int, user_text: str, message: Messa
     return await _run_streaming_reply(chat_id, user_text, message, provider="openrouter", model_id=model_id, piece_agen=piece_agen, deadline=deadline)
 
 async def _try_groq_streaming(chat_id: int, user_text: str, message: Message, model_id: str, *, deadline: float | None = None) -> tuple[str | None, Message | None]:
-    """Обёртка _run_streaming_reply для Groq (SSE через chat/completions)."""
+    """Обёртка _run_streaming_reply для Groq (SSE через chat/completions). Историю режем тем же _trim_messages_for_groq, что обычный путь, — иначе стрим-проба падает с 413 ещё до цепочки."""
     import bot
-    messages = bot._build_openrouter_turn_messages(chat_id, user_text, model_id)
+    from lumen_routes import _trim_messages_for_groq
+    messages = _trim_messages_for_groq(bot._build_openrouter_turn_messages(chat_id, user_text, model_id))
     # Генератор — через bot.: тесты подменяют bot._groq_stream_pieces фейком.
     piece_agen = bot._groq_stream_pieces(model_id, messages, deadline=deadline)
     return await _run_streaming_reply(chat_id, user_text, message, provider="groq", model_id=model_id, piece_agen=piece_agen, deadline=deadline)

tests/test_bot_routes.py

@@ -1382,6 +1382,64 @@ def test_ask_groq_text_raises_last_error_when_whole_chain_fails(monkeypatch):
         asyncio.run(bot.ask_groq_text(chat_id, "привет", model_chain=["qwen/qwen3.8-27b", "openai/gpt-oss-120b"]))
 
 
+def test_ask_groq_text_trims_long_history_to_token_budget(monkeypatch):
+    # Прод 05–07.10.2026: история 9–27K токенов давала HTTP 413 на каждую попытку
+    # Groq. Падает на старом коде, где история ехала целиком.
+    import lumen_routes
+    from collections import deque
+    chat_id = 999706
+    history = []
+    for i in range(60):
+        history.append({"role": "user", "content": "вопрос %d " % i + "x" * 500})
+        history.append({"role": "assistant", "content": "ответ %d " % i + "y" * 500})
+    monkeypatch.setattr(bot, "get_state", lambda cid: {"history": history, "ctx": deque()})
+    seen = {}
+
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+        # Первый запрос — сам ответ; второй (если будет) — саммаризатор истории
+        # _trim_history, его не трогаем.
+        seen.setdefault("messages", json_body["messages"])
+        return {"choices": [{"message": {"content": "ok"}}]}
+
+    monkeypatch.setattr(bot, "_groq_request", fake_groq_request)
+    monkeypatch.setattr(bot, "GROQ_API_KEY", "fake-key")
+    monkeypatch.setattr(bot, "_record_quota_usage", lambda provider, model, service=False: None)
+    assert asyncio.run(bot.ask_groq_text(chat_id, "текущий вопрос", model_chain=["qwen/qwen3.8-27b"])) == "ok"
+    msgs = seen["messages"]
+    total = sum(lumen_routes._estimate_tokens(m.get("content") if isinstance(m.get("content"), str) else "") for m in msgs)
+    assert total <= lumen_routes._GROQ_PROMPT_TOKEN_BUDGET
+    # Системный промпт и текущий вопрос на месте, хранимая история не ужата.
+    assert msgs[0]["role"] == "system"
+    assert msgs[-1]["content"].endswith("текущий вопрос")
+    # Хранимая история ужатию не подлежит: текущий вопрос-ответ дописаны как есть.
+    assert history[-2]["content"] == "текущий вопрос"
+    assert history[-1] == {"role": "assistant", "content": "ok"}
+
+
+def test_model_attempt_counters_track_chain_success_and_failure(monkeypatch):
+    # 08.10.2026: по счётчикам model_attempts/model_failures виден реальный КПД
+    # маршрута (раньше делили ответы на попытки только вручную по логам).
+    from collections import deque
+    chat_id = 999707
+    monkeypatch.setattr(bot, "get_state", lambda cid: {"history": [], "ctx": deque()})
+    calls = {"n": 0}
+
+    async def fake_groq_request(path, method="GET", *, json_body=None, deadline=None):
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise bot.GroqAPIError("boom", status_code=500)
+        return {"choices": [{"message": {"content": "ok"}}]}
+
+    monkeypatch.setattr(bot, "_groq_request", fake_groq_request)
+    monkeypatch.setattr(bot, "GROQ_API_KEY", "fake-key")
+    monkeypatch.setattr(bot, "_record_quota_usage", lambda provider, model, service=False: None)
+    before_a = bot._stats_entry().get("model_attempts", 0)
+    before_f = bot._stats_entry().get("model_failures", 0)
+    assert asyncio.run(bot.ask_groq_text(chat_id, "привет", model_chain=["qwen/qwen3.8-27b", "openai/gpt-oss-120b"])) == "ok"
+    assert bot._stats_entry().get("model_attempts", 0) - before_a == 2
+    assert bot._stats_entry().get("model_failures", 0) - before_f == 1
+
+
 def test_shared_chain_raises_budget_error_without_second_attempt(monkeypatch):
     # Общий цикл не должен тратить вторую попытку, если бюджет маршрута истёк.
     from collections import deque