feat(pool): bascule auto sur cle API invalide (400 INVALID_ARGUMENT)

Si une cle du pool est invalide (typo, revoquee, jamais activee pour
Gemini), Google renvoie 400 INVALID_ARGUMENT avec reason
'API_KEY_INVALID'. Avant : l'erreur remontait au LLM. Maintenant :
on marque la cle comme INVALIDE pour la session (permanent, pas reset
a minuit comme PerDay) et on bascule sur la suivante du pool.

- jarvis.is_invalid_api_key(exc) : detection via 'API_KEY_INVALID' ou
'API key not valid' dans le message.
- app._INVALID_KEYS : set des cles marquees invalides pour la session.
- app.mark_gemini_key_invalid(key) : ajoute au set.
- app.pick_unblown_gemini_key : exclut maintenant aussi les cles
invalides (avant les checks de PerDay).
- run_jarvis_flow + chat_with_agent : branche 'is_invalid_api_key'
AVANT 'is_per_day_quota_exhausted' (priorite plus haute). Meme
pattern : mark + pick next + rebuild LLM + agent + yield UI +
continue. UI message '🔑 Cle Google invalide detectee - bascule
sur une autre cle du pool'.

Si toutes les cles sont invalides ou epuisees : RuntimeError clair.

Tests : 3 nouveaux (detects 400, false on 429, false on generic).
183 tests verts.

app.py

@@ -320,8 +320,6 @@ def _parse_google_keys() -> list[str]:
     return [single] if single else []
 
 
-# Marquage in-memory des clés épuisées par jour UTC.
-# Format : {(api_key, "YYYY-MM-DD"): True}
 # Marquage in-memory **par (clé, modèle)** : chaque modèle Gemini a
 # son propre quota PerDay → une clé peut être blown pour
 # gemini-3.1-flash-lite mais OK pour gemini-3.5-flash. Format :
@@ -329,6 +327,19 @@ def _parse_google_keys() -> list[str]:
 # Reset implicite à minuit UTC (l'entrée du jour précédent n'existe plus).
 _BLOWN_TODAY: dict[tuple[str, str, str], bool] = {}
 
+# Clés marquées comme INVALIDES (typo, révoquée, etc.) — exclusion
+# PERMANENTE pour la session courante (pas reset à minuit). Détecté
+# via le code 400 INVALID_ARGUMENT / API_KEY_INVALID renvoyé par
+# l'API Google quand on tente d'utiliser une clé bidon.
+_INVALID_KEYS: set[str] = set()
+
+
+def mark_gemini_key_invalid(key: str) -> None:
+    """Marque une clé comme définitivement invalide pour la session
+    (typo, révoquée, jamais activée pour Gemini, etc.)."""
+    if key:
+        _INVALID_KEYS.add(key)
+
 
 def _today_utc_str() -> str:
     from datetime import datetime, timezone
@@ -348,12 +359,17 @@ def pick_unblown_gemini_key(model: str,
     (utilisé pour ne pas re-choisir celle qui vient de hit le PerDay).
 
     `model` est requis : chaque modèle Gemini a son propre quota PerDay,
-    donc une clé peut être blown pour un modèle et OK pour un autre."""
+    donc une clé peut être blown pour un modèle et OK pour un autre.
+
+    Exclut aussi les clés marquées comme INVALIDES (API_KEY_INVALID)
+    pour la session courante."""
     keys = _parse_google_keys()
     today = _today_utc_str()
     for k in keys:
         if k == skip:
             continue
+        if k in _INVALID_KEYS:
+            continue
         if not _BLOWN_TODAY.get((k, model, today), False):
             return k
     return None
@@ -807,6 +823,44 @@ def chat_with_agent(message: str, history: list[dict], api_key: str, model: str,
                 # Sortie normale → on quitte le while
                 break
             except Exception as e:
+                # 0) Clé API invalide → marque + switch.
+                from jarvis import is_invalid_api_key
+                if is_invalid_api_key(e):
+                    switched = False
+                    try:
+                        if current_gemini_key:
+                            mark_gemini_key_invalid(current_gemini_key)
+                        next_key = pick_unblown_gemini_key(
+                            model, skip=current_gemini_key
+                        )
+                        if next_key:
+                            pool_n = gemini_pool_size()
+                            current_gemini_key = next_key
+                            llm = _build_llm(
+                                model, api_key,
+                                use_thinking=use_thinking,
+                                gemini_key_override=current_gemini_key,
+                            )
+                            agent = build_jdm_agent(
+                                client=get_client(), llm=llm
+                            )
+                            switch_msg = (
+                                f"\n\n*🔑 Clé Google invalide détectée — "
+                                f"bascule sur une autre clé du pool "
+                                f"(pool : {pool_n} clés).*"
+                            )
+                            current_progress = "\n\n".join(progress_live)
+                            yield current_progress + switch_msg, _NOOP_FILE
+                            switched = True
+                    except Exception:
+                        pass
+                    if switched:
+                        continue
+                    raise RuntimeError(
+                        "Toutes les clés du pool Google sont soit "
+                        "invalides, soit épuisées pour aujourd'hui. "
+                        "Vérifie GOOGLE_API_KEYS."
+                    ) from e
                 # 1) Quota QUOTIDIEN épuisé SUR LE MODÈLE COURANT.
                 # On filtre par expected_model pour ignorer les PerDay
                 # parasites venant d'un autre modèle (ex : un quota

jarvis.py

@@ -253,6 +253,15 @@ def count_consolidated_in_messages(messages: list) -> int:
     return n
 
 
+def is_invalid_api_key(exc) -> bool:
+    """Détecte une clé API invalide (typo, révoquée, jamais activée
+    pour Gemini, etc.). Google renvoie alors 400 INVALID_ARGUMENT avec
+    `reason: 'API_KEY_INVALID'`. À traiter comme exclusion permanente
+    (la clé ne deviendra pas valide en attendant) → bascule de clé."""
+    msg = str(exc)
+    return "API_KEY_INVALID" in msg or "API key not valid" in msg
+
+
 def _extract_quota_model(exc) -> Optional[str]:
     """Extrait l'identifiant du modèle concerné par un quota épuisé,
     via `quotaDimensions.model` dans le message d'erreur.
@@ -1315,6 +1324,57 @@ def run_jarvis_flow(
                         # tente de basculer sur la suivante non-blown.
                         # Sinon (pool vide / toutes blown), on signale
                         # et on stop.
+                        # 0) Clé API invalide (typo, révoquée). Marquer
+                        # la clé courante comme invalide pour la session
+                        # et basculer sur la suivante du pool. Même
+                        # logique que PerDay (rebuild LLM + agent +
+                        # continue), mais marquage différent (permanent).
+                        if is_invalid_api_key(e):
+                            switched = False
+                            try:
+                                from app import (
+                                    mark_gemini_key_invalid,
+                                    pick_unblown_gemini_key,
+                                    gemini_pool_size,
+                                )
+                                if current_gemini_key:
+                                    mark_gemini_key_invalid(current_gemini_key)
+                                next_key = pick_unblown_gemini_key(
+                                    model, skip=current_gemini_key
+                                )
+                                if next_key:
+                                    pool_n = gemini_pool_size()
+                                    current_gemini_key = next_key
+                                    llm = build_llm_fn(
+                                        model, api_key,
+                                        use_thinking=use_thinking,
+                                        gemini_key_override=current_gemini_key,
+                                    )
+                                    agent = build_agent_fn(
+                                        client=get_client_fn(), llm=llm
+                                    )
+                                    _add_line(
+                                        f"*🔑 Clé Google invalide détectée — "
+                                        f"bascule sur une autre clé du pool "
+                                        f"(pool : {pool_n} clés).*"
+                                    )
+                                    yield (
+                                        [{"role": "user", "content": user_display},
+                                         {"role": "assistant",
+                                          "content": "\n\n".join(progress_live)}],
+                                        last_file_path,
+                                        _read_file_preview(last_file_path),
+                                    )
+                                    switched = True
+                            except Exception:
+                                pass
+                            if switched:
+                                continue
+                            raise RuntimeError(
+                                "Toutes les clés du pool Google sont soit "
+                                "invalides, soit épuisées pour aujourd'hui. "
+                                "Vérifie GOOGLE_API_KEYS dans tes secrets / .env."
+                            ) from e
                         # On filtre par expected_model : un PerDay sur
                         # un AUTRE modèle (ex. gemini-2.5 alors qu'on
                         # est sur 3.1) ne nous concerne pas, on l'ignore

tests/test_jarvis_helpers.py

@@ -19,6 +19,7 @@ from jarvis import (
     build_signalement_prompt,
     build_stats_prompt,
     detect_rate_limit_retry,
+    is_invalid_api_key,
     is_per_day_quota_exhausted,
 )
 
@@ -68,6 +69,31 @@ def test_is_per_day_quota_exhausted_false_on_non_quota():
     assert is_per_day_quota_exhausted(ValueError("foo")) is False
 
 
+_GEMINI_400_INVALID_KEY = (
+    "Error calling model 'gemini-3.1-flash-lite' (INVALID_ARGUMENT): 400 "
+    "INVALID_ARGUMENT. {'error': {'code': 400, 'message': 'API key not "
+    "valid. Please pass a valid API key.', 'status': 'INVALID_ARGUMENT', "
+    "'details': [{'reason': 'API_KEY_INVALID', "
+    "'domain': 'googleapis.com'}]}}"
+)
+
+
+def test_is_invalid_api_key_detects_400():
+    """Détection de la clé Google invalide (400 INVALID_ARGUMENT)."""
+    assert is_invalid_api_key(Exception(_GEMINI_400_INVALID_KEY)) is True
+
+
+def test_is_invalid_api_key_false_on_quota():
+    """Une 429 quota n'est PAS une clé invalide."""
+    assert is_invalid_api_key(Exception(_GEMINI_429_PERMINUTE)) is False
+
+
+def test_is_invalid_api_key_false_on_other():
+    """Erreur générique : pas une clé invalide."""
+    assert is_invalid_api_key(ValueError("foo")) is False
+    assert is_invalid_api_key(Exception("Connection refused")) is False
+
+
 def test_is_per_day_quota_exhausted_filter_by_model():
     """Avec expected_model, ne renvoie True QUE si le quota PerDay
     concerne le modèle attendu."""