fix(limiteur): attente bornee, 429 retenus, mentions dans la langue de la reponse

Issus de la revue de la branche :

- L'attente d'une place de generation (4 par modele) n'avait pas de
limite : quand toutes etaient prises par des comparaisons longues, un
message du chat attendait des minutes, sans secours ni 503. Elle est
bornee par l'attente acceptee ; au-dela, le modele de secours.
- Mistral : un Retry-After plus long que le budget, ou recu au dernier
essai, n'etait pas inscrit au limiteur ; l'appel suivant retournait
frapper le modele sanctionne. Il est inscrit avant de decider
d'abandonner.
- Un `repousser` (429) ne retenait pas les appels deja endormis sur un
depart reserve : ils partaient en pleine penalite. Ils attendent
l'echeance.
- Le recalage sur les en-tetes de Groq s'inscrivait en queue de fenetre,
apres des departs reserves pour plus tard, et le calcul du prochain
depart faisait attendre trop (88 s au lieu de 59). Il s'inscrit a sa
place. Groq corrige l'usage reel AVANT de recaler, sinon l'estimation
masquait la consommation des autres processus.
- Les mentions de fin suivent la langue de la reponse ; une fin « error »
est une interruption (« reposez la question »), pas une longueur ;
l'explication d'article n'invite plus a « poser une question plus
precise ».

Tests : garde reseau ignoree sous JURIX_E2E (rien a garder), semaphore
par boucle verifie sous contention (sans elle, il ne se lie a aucune
boucle et le test ne prouvait rien), Retry-After distinct de l'espacement
du limiteur, GROQ_ATTENTE_MAX_429_S epingle (un .env le changeait).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/core/limiteur.py

@@ -124,10 +124,20 @@ class _Fenetre:
         return debut  # inatteignable : la fenetre vide accepte toujours
 
     def ajouter(self, instant: float, quantite: int) -> Optional[list]:
+        """
+        Inscrit une entree A SA PLACE dans le temps. Les departs reserves
+        arrivent dans l'ordre, mais un recalage (consommation des autres
+        processus, inscrite a « maintenant ») peut tomber avant des departs
+        deja reserves pour plus tard : ajoutee en queue, elle faussait
+        `premier_instant`, qui suppose l'ordre.
+        """
         if self.plafond is None:
             return None
         entree = [instant, quantite]
-        self.entrees.append(entree)
+        position = len(self.entrees)
+        while position > 0 and self.entrees[position - 1][0] > instant:
+            position -= 1
+        self.entrees.insert(position, entree)
         return entree
 
     def total(self, instant: float) -> int:
@@ -352,8 +362,13 @@ class Limiteur:
     ) -> Reservation:
         """Reserve, puis dort jusqu'au depart (sans bloquer la boucle)."""
         reservation = self.reserver(jetons, attente_max, jetons_entree=jetons_entree)
+        debut = self._horloge()
         if reservation.attente > 0:
             await self._dormir_async(reservation.attente)
+        supplement = self._supplement(debut, attente_max)
+        while supplement > 0:
+            await self._dormir_async(supplement)
+            supplement = self._supplement(debut, attente_max)
         return reservation
 
     def attendre_sync(
@@ -365,10 +380,35 @@ class Limiteur:
     ) -> Reservation:
         """Reserve, puis dort jusqu'au depart : pour le pipeline et les scripts."""
         reservation = self.reserver(jetons, attente_max, jetons_entree=jetons_entree)
+        debut = self._horloge()
         if reservation.attente > 0:
             self._dormir(reservation.attente)
+        supplement = self._supplement(debut, attente_max)
+        while supplement > 0:
+            self._dormir(supplement)
+            supplement = self._supplement(debut, attente_max)
         return reservation
 
+    def _supplement(self, debut: float, attente_max: Optional[float]) -> float:
+        """
+        L'attente qu'impose un `repousser` survenu PENDANT le sommeil.
+
+        Un appelant deja endormi partait a l'heure reservee, en plein dans la
+        penalite qu'un 429 venait d'imposer : chaque depart reserve recoltait
+        son propre 429. Au-dela de `attente_max` (compte depuis la
+        reservation), AttenteTropLongue ; la reservation reste comptee, ce qui
+        est prudent.
+        """
+        with self._verrou:
+            maintenant = self._horloge()
+            supplement = self._pas_avant - maintenant
+            raison = self._raison_pas_avant
+        if supplement <= 0:
+            return 0.0
+        if attente_max is not None and maintenant + supplement - debut > attente_max:
+            raise AttenteTropLongue(self.nom, maintenant + supplement - debut, raison)
+        return supplement
+
     @asynccontextmanager
     async def creneau(
         self,
@@ -383,12 +423,27 @@ class Limiteur:
         La place est prise AVANT la reservation : reserver d'abord ferait
         partir la requete plus tard que prevu, et les fenetres compteraient
         un depart qui n'a pas eu lieu a l'instant inscrit.
+
+        `attente_max` borne AUSSI l'attente d'une place : sans cela, quand
+        toutes les places sont prises par des generations longues, l'appel
+        attendait sans limite, et ni le modele de secours ni le 503 promis
+        n'arrivaient. Le temps passe a attendre la place est deduit du budget
+        de la reservation.
         """
         semaphore = self._semaphore()
+        restant = attente_max
         if semaphore is not None:
-            await semaphore.acquire()
+            if attente_max is None:
+                await semaphore.acquire()
+            else:
+                debut = time.monotonic()
+                try:
+                    await asyncio.wait_for(semaphore.acquire(), timeout=attente_max)
+                except asyncio.TimeoutError:
+                    raise AttenteTropLongue(self.nom, attente_max, "concurrence") from None
+                restant = max(0.0, attente_max - (time.monotonic() - debut))
         try:
-            yield await self.attendre(jetons, attente_max, jetons_entree=jetons_entree)
+            yield await self.attendre(jetons, restant, jetons_entree=jetons_entree)
         finally:
             if semaphore is not None:
                 semaphore.release()

app/services/explanation_service.py

@@ -161,7 +161,7 @@ class ExplanationService:
         prompt = self._construire_prompt(law, chunks, numero_resolu, langue)
         systeme = get_system_prompt(EXPLANATION_PERSONA, langue)
 
-        texte = await self._generer(prompt, systeme)
+        texte = await self._generer(prompt, systeme, langue)
 
         duree_ms = int((time.perf_counter() - debut) * 1000)
         logger.info(
@@ -341,7 +341,7 @@ class ExplanationService:
 
         return "\n".join(entete) + "\n\n" + contexte + "\n" + tache
 
-    async def _generer(self, prompt: str, systeme: str) -> str:
+    async def _generer(self, prompt: str, systeme: str, langue: str = "fr") -> str:
         """
         Appelle le modele et traduit ses echecs.
 
@@ -367,5 +367,6 @@ class ExplanationService:
         if not texte.strip():
             raise ExplanationError("Le modèle n'a produit aucune explication.")
         # Une explication coupee le dit : sinon sa derniere phrase, inachevee,
-        # passerait pour la fin du raisonnement.
-        return texte + mention_de_reponse(reponse)
+        # passerait pour la fin du raisonnement. Sans conseil : il n'y a pas de
+        # question a reformuler derriere le bouton « Expliquer ».
+        return texte + mention_de_reponse(reponse, langue, conseil=False)

app/services/groq_service.py

@@ -279,14 +279,19 @@ class GroqService:
         repousse), ou une exception. Commun aux chemins sync et async.
         """
         limiteur = self.limiteur(modele)
-        self._recaler(limiteur, reponse.headers)
         code = reponse.status_code
-
+        corps = None
         if code == 200:
             corps = reponse.json()
             usage = corps.get("usage") or {}
+            # Corriger AVANT de recaler : le recalage compare la fenetre a ce
+            # que Groq annonce, et l'estimation laissee en place y masquait la
+            # consommation des autres processus.
             if usage.get("total_tokens") is not None:
                 reservation.corriger(usage["total_tokens"], usage.get("prompt_tokens"))
+        self._recaler(limiteur, reponse.headers)
+
+        if code == 200:
             choix = corps["choices"][0]
             fin = choix.get("finish_reason")
             contenu = (choix.get("message") or {}).get("content") or ""

app/services/llm.py

@@ -18,6 +18,7 @@ from typing import Any, Dict, Optional
 
 from app.core.config import settings
 from app.services.gemini_service import (
+    GeminiBudgetEpuiseError,
     GeminiOverloadedError,
     GeminiQuotaError,
     GeminiServiceError,
@@ -38,39 +39,57 @@ ERREURS_QUOTA = (GeminiQuotaError, MistralQuotaError)
 ERREURS_SATURATION = (GeminiOverloadedError, MistralOverloadedError)
 # Toute erreur de generation, y compris les deux familles ci-dessus.
 ERREURS_LLM = (GeminiServiceError, MistralServiceError)
+# Budget epuise avant toute sortie : un budget plus grand peut suffire.
+ERREURS_BUDGET = (GeminiBudgetEpuiseError,)
 
-# Ajoutee a une reponse que le modele n'a pas pu finir : sans elle, une phrase
-# coupee ressemble a une reponse complete.
-MENTION_REPONSE_TRONQUEE = (
-    "\n\n*(Réponse interrompue : longueur maximale atteinte. "
-    "Posez une question plus précise pour obtenir la suite.)*"
-)
-# Le flux s'est rompu en cours de reponse, et la suite demandee a echoue :
-# incomplete, mais pas a cause de sa longueur.
-MENTION_REPONSE_INTERROMPUE = (
-    "\n\n*(Réponse interrompue : la connexion avec le modèle a été coupée. "
-    "Reposez la question pour obtenir une réponse complète.)*"
-)
+# Ajoutees a une reponse que le modele n'a pas pu finir : sans elles, une
+# phrase coupee ressemble a une reponse complete. Deux causes, deux remedes :
+# la LONGUEUR (poser une question plus precise) et l'INTERRUPTION — flux
+# rompu, ou fin « error » du fournisseur — (reposer la question). Dans la
+# langue de la reponse ; sans conseil quand il n'y a pas de question a
+# reformuler (l'explication d'un article).
+_MENTIONS = {
+    "fr": {
+        "longueur": "Réponse interrompue : longueur maximale atteinte.",
+        "conseil_longueur": "Posez une question plus précise pour obtenir la suite.",
+        "interruption": "Réponse interrompue : la connexion avec le modèle a été coupée.",
+        "conseil_interruption": "Reposez la question pour obtenir une réponse complète.",
+    },
+    "en": {
+        "longueur": "Answer cut short: maximum length reached.",
+        "conseil_longueur": "Ask a more specific question to get the rest.",
+        "interruption": "Answer interrupted: the connection with the model was lost.",
+        "conseil_interruption": "Ask again to get a complete answer.",
+    },
+}
+# Fins dues a une interruption, et non a la longueur.
+_FINS_INTERROMPUES = frozenset({FIN_INTERROMPUE, "ERROR"})
 
 
-def mention_de_fin(fin: Optional[str]) -> str:
+def mention_de_fin(fin: Optional[str], langue: str = "fr", conseil: bool = True) -> str:
     """
     La mention a ajouter a une reponse selon sa fin, ou "" si elle est
     complete. `fin` suit le vocabulaire commun (« STOP », « MAX_TOKENS »...) ;
     Gemini et Mistral le partagent.
     """
-    if fin == FIN_INTERROMPUE:
-        return MENTION_REPONSE_INTERROMPUE
-    if fin in FINS_INCOMPLETES:
-        return MENTION_REPONSE_TRONQUEE
-    return ""
+    if fin not in FINS_INCOMPLETES:
+        return ""
+    textes = _MENTIONS.get(langue, _MENTIONS["fr"])
+    cause = "interruption" if fin in _FINS_INTERROMPUES else "longueur"
+    phrase = textes[cause] + (" " + textes[f"conseil_{cause}"] if conseil else "")
+    return f"\n\n*({phrase})*"
 
 
-def mention_de_reponse(reponse: Dict[str, Any]) -> str:
+def mention_de_reponse(reponse: Dict[str, Any], langue: str = "fr", conseil: bool = True) -> str:
     """La mention d'une reponse de `generate` : coupee si elle le dit."""
     if not (reponse or {}).get("tronquee"):
         return ""
-    return mention_de_fin(reponse.get("fin") or "MAX_TOKENS")
+    return mention_de_fin(reponse.get("fin") or "MAX_TOKENS", langue, conseil)
+
+
+# Les mentions francaises completes, telles que le chat les affiche.
+MENTION_REPONSE_TRONQUEE = mention_de_fin("MAX_TOKENS")
+MENTION_REPONSE_INTERROMPUE = mention_de_fin(FIN_INTERROMPUE)
 
 
 def get_llm_service() -> Any:

app/services/mistral_service.py

@@ -332,13 +332,16 @@ FORBIDDEN:
                         reponse.status_code, reponse.content, reponse.headers, essai
                     )
                     cause = f"HTTP {reponse.status_code}"
+                # Le delai impose est inscrit AVANT de decider d'abandonner :
+                # sinon un Retry-After plus long que le budget etait perdu, et
+                # l'appel suivant repartait aussitot vers le modele sanctionne.
+                limiteur.repousser(attente, cause)
                 if self._abandonner(limiteur, debut, essai, attente):
                     break
                 logger.warning(
                     "⚠️ Mistral %s : %s, nouvel essai dans %.1f s (%d/%d)",
                     modele, cause, attente, essai, ESSAIS,
                 )
-                limiteur.repousser(attente, cause)
 
         secours = self._secours(modele) if secours_permis else None
         if secours:
@@ -401,13 +404,13 @@ FORBIDDEN:
                 except AttenteTropLongue as e:
                     cause = f"attente {e.attente:.0f} s ({e.raison})"
                     break
+                limiteur.repousser(attente, cause)
                 if self._abandonner(limiteur, debut, essai, attente):
                     break
                 logger.warning(
                     "⚠️ Mistral %s (flux) : %s, nouvel essai dans %.1f s (%d/%d)",
                     modele, cause, attente, essai, ESSAIS,
                 )
-                limiteur.repousser(attente, cause)
 
         secours = self._secours(modele) if secours_permis else None
         if secours:

app/services/rag_service.py

@@ -457,7 +457,7 @@ class RAGService:
             max_tokens=ANSWER_MAX_TOKENS, reflexion=settings.GEMINI_REFLEXION_REPONSE,
         )
         generation_time_ms = int((time.time() - generation_start) * 1000)
-        answer = llm_response["response"] + mention_de_reponse(llm_response)
+        answer = llm_response["response"] + mention_de_reponse(llm_response, request.language)
 
         # Extract citations
         citations = self._extract_citations(answer, search_results)
@@ -526,7 +526,7 @@ class RAGService:
         generation_time_ms = int((time.time() - generation_start) * 1000)
         # Deux phrases attendues, mais un budget de jetons tout de meme : une
         # reponse coupee le dit, ici comme ailleurs.
-        answer = llm_response["response"] + mention_de_reponse(llm_response)
+        answer = llm_response["response"] + mention_de_reponse(llm_response, request.language)
 
         # `_calculate_confidence` n'est PAS appele : ses quatre facteurs
         # mesurent l'ancrage documentaire d'une reponse (citations, pertinence
@@ -694,7 +694,7 @@ class RAGService:
 
             # Une reponse restee incomplete le dit, comme dans `ask` : coupee
             # par le budget malgre la suite demandee, ou flux rompu.
-            mention = mention_de_fin(raison.get("fin"))
+            mention = mention_de_fin(raison.get("fin"), request.language)
             if mention:
                 answer_parts.append(mention)
                 yield RAGStreamChunk(chunk=mention, done=False).model_dump_json(exclude_none=True)

tests/test_core/test_limiteur.py

@@ -209,6 +209,25 @@ class TestRecaler:
         assert lim.reserver(jetons=50).attente == 0.0
         assert lim.reserver(jetons=200).attente == pytest.approx(60.0)
 
+    def test_l_ecart_s_inscrit_a_sa_place_dans_le_temps(self, horloge):
+        """
+        Le recalage tombe a « maintenant », AVANT un depart deja reserve pour
+        plus tard. Ajoute en queue, il faisait attendre 88 s au lieu de 59.
+        """
+        lim = limiteur(horloge, jetons_par_minute=8000)
+        horloge.t = 99.0
+        lim.reserver(jetons=1000)
+        lim.repousser(31)
+        assert lim.reserver(jetons=3000).depart == pytest.approx(130.0)
+        horloge.t = 101.0
+        lim.recaler(jetons_restants_minute=2000)  # les autres ont pris 2 000
+
+        horloge.t = 102.0
+        reservation = lim.reserver(jetons=4000)
+
+        # A 161, l'ecart (inscrit a 101) est sorti de la fenetre : 3 000 + 4 000.
+        assert reservation.depart == pytest.approx(161.0)
+
     def test_requetes_du_jour_recalees(self, horloge):
         lim = limiteur(horloge, requetes_par_jour=10)
 
@@ -220,6 +239,41 @@ class TestRecaler:
 
 
 class TestAttendre:
+    def test_un_429_pendant_le_sommeil_retarde_le_depart(self, horloge):
+        """
+        Un autre appel recoit un 429 pendant que celui-ci dort : partir a
+        l'heure reservee, c'etait partir en pleine penalite.
+        """
+        lim = limiteur(horloge, requetes_par_minute=30)
+        lim.reserver()
+        dormir = horloge.dormir
+
+        def dormir_et_subir_un_429(secondes):
+            dormir(secondes)
+            if len(horloge.sommeils) == 1:
+                lim.repousser(10, "429")
+
+        lim._dormir = dormir_et_subir_un_429
+
+        lim.attendre_sync()
+
+        assert horloge.sommeils == [2.0, 10.0]
+        assert horloge.t == pytest.approx(1012.0)
+
+    def test_le_supplement_respecte_attente_max(self, horloge):
+        lim = limiteur(horloge, requetes_par_minute=30)
+        lim.reserver()
+        dormir = horloge.dormir
+
+        def dormir_et_subir_un_429(secondes):
+            dormir(secondes)
+            lim.repousser(60, "429")
+
+        lim._dormir = dormir_et_subir_un_429
+
+        with pytest.raises(AttenteTropLongue):
+            lim.attendre_sync(attente_max=5)
+
     def test_synchrone_dort_l_attente(self, horloge):
         lim = limiteur(horloge, requetes_par_minute=30)
 
@@ -260,15 +314,45 @@ class TestConcurrence:
         assert dedans == ["a", "b"]
 
     def test_un_semaphore_par_boucle(self, horloge):
-        """Partage entre deux boucles, un asyncio.Semaphore leverait RuntimeError."""
-        lim = limiteur(horloge, concurrence=2)
+        """
+        Partage entre deux boucles, un asyncio.Semaphore leverait RuntimeError.
+        Il ne se lie a sa boucle que lorsqu'un appel doit ATTENDRE : d'ou deux
+        appels concurrents pour une seule place, dans chaque boucle.
+        """
+        lim = limiteur(horloge, concurrence=1)
+
+        async def deux_appels():
+            async def appel():
+                async with lim.creneau():
+                    await asyncio.sleep(0)
+
+            await asyncio.gather(appel(), appel())
+
+        asyncio.run(deux_appels())
+        asyncio.run(deux_appels())
 
-        async def appel():
+    async def test_l_attente_d_une_place_est_bornee(self, horloge):
+        """
+        Toutes les places prises par des generations longues : l'appel
+        attendait sans limite, sans secours ni 503.
+        """
+        lim = limiteur(horloge, concurrence=1)
+        liberer = asyncio.Event()
+
+        async def occuper():
             async with lim.creneau():
-                await asyncio.sleep(0)
+                await liberer.wait()
+
+        occupant = asyncio.create_task(occuper())
+        await asyncio.sleep(0)
+
+        with pytest.raises(AttenteTropLongue) as erreur:
+            async with lim.creneau(attente_max=0.05):
+                pass
 
-        asyncio.run(appel())
-        asyncio.run(appel())
+        assert erreur.value.raison == "concurrence"
+        liberer.set()
+        await occupant
 
     async def test_le_refus_rend_la_place(self, horloge):
         lim = limiteur(horloge, requetes_par_minute=30, concurrence=1)

tests/test_qualite/test_garde_reseau.py

@@ -24,13 +24,18 @@ from app.services.groq_service import GroqService
 from app.services.mistral_service import MistralService
 from tests.conftest import CLE_FACTICE
 
+# JURIX_E2E=1 ouvre tout, vraies cles comprises : il n'y a alors aucune garde
+# a verifier, et ces tests echouaient sur un transport absent.
+pytestmark = pytest.mark.skipif(
+    os.environ.get("JURIX_E2E") == "1", reason="JURIX_E2E : aucune garde posee"
+)
+
 
 def _garde(module):
     """Le gardien derriere le transport pose par conftest."""
     return module.transport_http.handler.__self__
 
 
-@pytest.mark.skipif(os.environ.get("JURIX_E2E") == "1", reason="JURIX_E2E garde les vraies cles")
 @pytest.mark.parametrize("cle", ["GEMINI_API_KEY", "GROQ_API_KEY", "MISTRAL_API_KEY"])
 def test_les_cles_sont_factices(cle):
     assert getattr(settings, cle) == CLE_FACTICE

tests/test_services/test_explanation_service.py

@@ -387,15 +387,21 @@ class TestEchecsDuModele:
         with pytest.raises(ExplanationError):
             await service.explain(loi.id, "2", "fr")
 
-    async def test_explication_coupee_le_dit(self, db_session, loi, llm):
-        """Sa derniere phrase, inachevee, passerait pour la fin du raisonnement."""
-        from app.services.llm import MENTION_REPONSE_TRONQUEE
-
+    @pytest.mark.parametrize("langue, mention", [
+        ("fr", "*(Réponse interrompue : longueur maximale atteinte.)*"),
+        ("en", "*(Answer cut short: maximum length reached.)*"),
+    ])
+    async def test_explication_coupee_le_dit(self, db_session, loi, llm, langue, mention):
+        """
+        Sa derniere phrase, inachevee, passerait pour la fin du raisonnement.
+        Dans la langue demandee, et sans « posez une question plus precise » :
+        il n'y a pas de question derriere le bouton « Expliquer ».
+        """
         llm.generate.return_value = {
             "response": "**En clair**\n\nCet article impose", "tronquee": True, "fin": "MAX_TOKENS",
         }
         service = ExplanationService(db_session, llm=llm)
 
-        reponse = await service.explain(loi.id, "2", "fr")
+        reponse = await service.explain(loi.id, "2", langue)
 
-        assert reponse.explanation.endswith(MENTION_REPONSE_TRONQUEE)
+        assert reponse.explanation.endswith(mention)

tests/test_services/test_groq_service.py

@@ -13,6 +13,7 @@ import json
 import httpx
 import pytest
 
+from app.core.config import settings
 from app.core.limiteur import Limiteur
 from app.services import groq_service
 from app.services.groq_service import (
@@ -92,6 +93,8 @@ def horloge():
 @pytest.fixture
 def groq(monkeypatch, horloge):
     """Un service sur faux transport, avec des limiteurs sur horloge factice."""
+    # Lu a chaque appel : un .env qui le changerait changerait ces tests.
+    monkeypatch.setattr(settings, "GROQ_ATTENTE_MAX_429_S", 120.0)
     limiteurs = {}
 
     def limiteur_pour(modele):
@@ -261,6 +264,23 @@ class TestLimiteur:
         assert erreur.value.retry_after == pytest.approx(150)
         assert len(faux.requetes) == 1
 
+    async def test_le_recalage_voit_les_autres_processus(self, groq):
+        """
+        Groq annonce 7 000 jetons restants sur 8 000 ; cet appel en a consomme
+        200 (estime a bien plus). Les 800 autres viennent d'un autre processus :
+        la fenetre doit totaliser ce que Groq compte. Recaler AVANT de corriger
+        laissait l'estimation masquer cette consommation.
+        """
+        service, faux = groq(ok(
+            {"intention": "juridique"}, jetons=200,
+            entetes={"x-ratelimit-remaining-tokens": "7000"},
+        ))
+        lim = service.limiteur(QWEN)
+
+        await _completer(service, max_jetons=3000)
+
+        assert lim._jetons_minute.total(lim.maintenant()) == 1000
+
     async def test_usage_reel_corrige_la_reservation(self, groq):
         """L'estimation (entree + max_jetons) est remplacee par l'usage reel."""
         service, faux = groq(ok({"intention": "juridique"}, jetons=200))

tests/test_services/test_intent_groq.py

@@ -67,6 +67,7 @@ def groq(monkeypatch):
     """
     monkeypatch.setattr(settings, "INTENT_CLASSIFIER", "groq")
     monkeypatch.setattr(settings, "GROQ_API_KEY", "cle-test")
+    monkeypatch.setattr(settings, "GROQ_ATTENTE_MAX_429_S", 120.0)
     intent_classifier.cache_des_verdicts.vider()
     horloge = Horloge()
     limiteur = Limiteur(

tests/test_services/test_llm.py

@@ -88,3 +88,29 @@ def test_quota_et_saturation_sont_aussi_des_erreurs_de_generation(erreur):
     """
     assert issubclass(erreur, ERREURS_LLM)
     assert issubclass(erreur, ERREURS_QUOTA + ERREURS_SATURATION)
+
+
+@pytest.mark.parametrize("fin, attendu", [
+    ("STOP", ""),
+    ("UNKNOWN", ""),
+    ("MAX_TOKENS", "longueur maximale atteinte"),
+    ("INTERROMPUE", "connexion avec le modèle a été coupée"),
+    # Une fin « error » du fournisseur n'est pas une affaire de longueur :
+    # « posez une question plus precise » serait le mauvais remede.
+    ("ERROR", "connexion avec le modèle a été coupée"),
+])
+def test_mention_selon_la_fin(fin, attendu):
+    from app.services.llm import mention_de_fin
+
+    mention = mention_de_fin(fin)
+
+    assert (attendu in mention) if attendu else mention == ""
+
+
+def test_mention_dans_la_langue_de_la_reponse():
+    from app.services.llm import mention_de_fin
+
+    assert "maximum length reached" in mention_de_fin("MAX_TOKENS", "en")
+    assert "Ask again" in mention_de_fin("ERROR", "en")
+    # Langue inconnue : le francais, jamais une mention vide.
+    assert "longueur maximale" in mention_de_fin("MAX_TOKENS", "de")

tests/test_services/test_mistral_service.py

@@ -16,6 +16,7 @@ Usage:
     pytest tests/test_services/test_mistral_service.py -m mistral_live
 """
 
+import asyncio
 import json
 
 import httpx
@@ -349,6 +350,45 @@ class TestSaturation:
         assert (await service.generate("p"))["response"] == "Oui."
         assert faux.modeles() == [SECOURS]
 
+    async def test_un_long_retry_after_est_retenu_meme_en_abandonnant(self, mistral):
+        """
+        30 s depassent le budget : l'appel passe au secours. Le delai doit
+        rester inscrit, sinon l'appel suivant retourne frapper le modele
+        sanctionne.
+        """
+        service, faux = mistral(
+            refus(429, "Rate limit", {"retry-after": "30"}),
+            ok("Oui.", modele=SECOURS),
+            ok("Encore.", modele=SECOURS),
+        )
+
+        await service.generate("p")
+        await service.generate("p")
+
+        assert faux.modeles() == [PRINCIPAL, SECOURS, SECOURS]
+
+    async def test_toutes_les_places_prises_va_au_secours(self, mistral, monkeypatch):
+        """L'attente d'une place etait sans limite : ni secours, ni 503."""
+        monkeypatch.setattr(settings, "MISTRAL_ATTENTE_MAX_S", 0.05)
+        service, faux = mistral(ok("Oui.", modele=SECOURS))
+        principal = service.limiteur(PRINCIPAL)
+        principal.concurrence = 1
+        liberer = asyncio.Event()
+
+        async def occuper():
+            async with principal.creneau():
+                await liberer.wait()
+
+        occupant = asyncio.create_task(occuper())
+        await asyncio.sleep(0)
+
+        resultat = await service.generate("p")
+
+        assert resultat["response"] == "Oui."
+        assert faux.modeles() == [SECOURS]
+        liberer.set()
+        await occupant
+
     async def test_sans_secours(self, mistral, monkeypatch):
         monkeypatch.setattr(settings, "MISTRAL_MODEL_SECOURS", "")
         service, faux = mistral(ok("Oui."))
@@ -437,12 +477,14 @@ class TestFlux:
             await _tout_lire(service)
 
     async def test_429_avant_le_premier_octet(self, mistral, horloge):
-        service, faux = mistral(refus(429, "Rate limit", {"retry-after": "2"}), flux("Oui."))
+        # 5 s, et non 2 : l'espacement du limiteur (2 s) masquerait un
+        # Retry-After ignore.
+        service, faux = mistral(refus(429, "Rate limit", {"retry-after": "5"}), flux("Oui."))
 
         morceaux, fins = await _tout_lire(service)
 
         assert morceaux == ["Oui."]
-        assert horloge.sommeils == [2.0]
+        assert horloge.sommeils == [5.0]
 
     async def test_secours_en_flux(self, mistral):
         trop = refus(429, "Rate limit", {"retry-after": "6"})

tests/test_services/test_rag_service.py

@@ -977,6 +977,21 @@ class TestFluxAligneSurAsk:
         texte = "".join(e["chunk"] for e in evenements)
         assert texte.endswith(MENTION_REPONSE_INTERROMPUE)
 
+    @pytest.mark.asyncio
+    async def test_mention_dans_la_langue_de_la_question(
+        self, rag_service, sample_rag_request, mock_search_results, mock_db_session
+    ):
+        """Une reponse en anglais ne se termine pas par une mention en francais."""
+        requete = sample_rag_request.model_copy(update={"language": "en"})
+        self._preparer(rag_service, mock_db_session, mock_search_results,
+                       ["A soldier who abuses "], raison="MAX_TOKENS")
+
+        evenements = await self._evenements(rag_service, requete)
+
+        texte = "".join(e["chunk"] for e in evenements)
+        assert texte.endswith("*(Answer cut short: maximum length reached. "
+                              "Ask a more specific question to get the rest.)*")
+
     @pytest.mark.asyncio
     async def test_reponse_complete_sans_mention(
         self, rag_service, sample_rag_request, mock_search_results, mock_db_session