No reintentar el 429 y limitar /api/interpret también por usuario

Dos cambios que atacan lo mismo: la cuota de GPU compartida es el recurso
escaso de una instancia pública gratuita, y hoy se malgasta.

1) El reintento no distinguía qué fallo estaba tratando.
service.py reintentaba ante cualquier ErrorModelo. Para la salida malformada
de medGemma (razonamiento filtrado, bucle de repetición) eso es correcto y es
su razón de ser. Para un 429 es contraproducente: gasta otra reserva de GPU
del mismo pozo agotado, justo cuando el Space pide parar. Para un rechazo por
seguridad o una clave ausente, no puede cambiar nada.

ErrorModelo pasa a llevar `reintentable` y `saturado`; cada punto de fallo se
clasifica (429 y cuota → no reintentable; 5xx → sí; config y rechazos → no).
Un 429 ahora cuesta UNA llamada en vez de dos.

/api/interpret responde 503 + Retry-After ante saturación, no un 502 genérico:
el 502 invita a recargar en bucle contra una cuota ya agotada.

2) El rate limit era sólo por IP.
ZeroGPU es por cuenta, no por Space: un usuario puede agotar la capacidad del
día para todos. La IP no sirve como identidad —cambia, y varios veterinarios
de una clínica la comparten y se penalizan entre sí—. Se añade un segundo
límite con la sesión como clave (20/hora por defecto, configurable).

Tests nuevos que cuentan LLAMADAS, que es lo que consume cuota: un 429 y un
rechazo cuestan una; la salida malformada sí se reintenta y acierta a la segunda;
el reintento no es infinito.

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

backend/app/ai/base.py

@@ -13,7 +13,22 @@ from ..schemas import InterpretacionClinica
 
 
 class ErrorModelo(Exception):
-    """Fallo recuperable/no recuperable al invocar un modelo o validar su salida."""
+    """Fallo al invocar un modelo o validar su salida.
+
+    `reintentable` decide si el servicio vuelve a muestrear. La distinción importa de verdad:
+    el reintento existe para la salida malformada de medGemma (razonamiento filtrado o bucle de
+    repetición), donde volver a muestrear suele funcionar. Reintentar un 429 hace lo contrario —
+    duplica la presión sobre la cuota de ZeroGPU, que es justo el recurso agotado— y reintentar
+    un rechazo por seguridad o una clave mal configurada no puede cambiar nada.
+
+    `saturado` marca los casos de límite de tasa/cuota, para poder responder 503 + Retry-After
+    en vez de un 502 genérico.
+    """
+
+    def __init__(self, mensaje: str, *, reintentable: bool = True, saturado: bool = False) -> None:
+        super().__init__(mensaje)
+        self.reintentable = reintentable
+        self.saturado = saturado
 
 
 class ClienteModelo(Protocol):

backend/app/ai/claude.py

@@ -44,7 +44,9 @@ class ClaudeClient:
     def __init__(self) -> None:
         cfg = obtener_config()
         if not cfg.anthropic_api_key:
-            raise ErrorModelo("ANTHROPIC_API_KEY no configurada para la ruta Claude.")
+            raise ErrorModelo(
+                "ANTHROPIC_API_KEY no configurada para la ruta Claude.", reintentable=False
+            )
         # Import perezoso para no exigir el SDK cuando sólo se usa medGemma.
         from anthropic import AsyncAnthropic
 
@@ -75,7 +77,8 @@ class ClaudeClient:
             raise ErrorModelo(
                 "El modelo rechazó la petición por sus filtros de seguridad"
                 + (f" (categoría: {categoria})" if categoria else "")
-                + ". Reformula el caso o usa la ruta medGemma."
+                + ". Reformula el caso o usa la ruta medGemma.",
+                reintentable=False,
             )
 
         for bloque in resp.content:
@@ -95,7 +98,9 @@ class ClaudeClient:
             messages=[{"role": "user", "content": mensaje}],
         )
         if resp.stop_reason == "refusal":
-            raise ErrorModelo("El juez rechazó el caso por sus filtros de seguridad.")
+            raise ErrorModelo(
+                "El juez rechazó el caso por sus filtros de seguridad.", reintentable=False
+            )
         texto = "".join(b.text for b in resp.content if getattr(b, "type", None) == "text")
         try:
             return json.loads(texto)

backend/app/ai/hf_space.py

@@ -107,7 +107,9 @@ class HFSpaceClient:
     def __init__(self) -> None:
         cfg = obtener_config()
         if not cfg.hf_space_url:
-            raise ErrorModelo("MORPHOS_HF_SPACE_URL no configurada para la ruta HF Space.")
+            raise ErrorModelo(
+                "MORPHOS_HF_SPACE_URL no configurada para la ruta HF Space.", reintentable=False
+            )
         self._space = cfg.hf_space_url.rstrip("/")
         self._key = cfg.hf_api_key
 
@@ -164,8 +166,21 @@ class HFSpaceClient:
                 )
             except httpx.HTTPError as exc:
                 raise ErrorModelo(f"No se pudo contactar el HF Space: {exc}") from exc
+            if r.status_code == 429:
+                # Cuota de ZeroGPU agotada o límite de tasa del router de HF. Reintentar aquí
+                # sería contraproducente: gasta otra reserva de GPU del mismo pozo agotado.
+                raise ErrorModelo(
+                    "El modelo está saturado (cuota de GPU agotada). Inténtalo de nuevo en unos "
+                    "minutos, o configura la ruta local de Ollama.",
+                    reintentable=False,
+                    saturado=True,
+                )
             if r.status_code >= 400:
-                raise ErrorModelo(f"HF Space devolvió HTTP {r.status_code}")
+                # 5xx puede ser transitorio; 4xx (auth, petición mal formada) no se arregla solo.
+                raise ErrorModelo(
+                    f"HF Space devolvió HTTP {r.status_code}",
+                    reintentable=r.status_code >= 500,
+                )
 
             event_id = (r.json() or {}).get("event_id")
             if not event_id:
@@ -180,7 +195,12 @@ class HFSpaceClient:
 
         texto, error = self._parsear_sse(stream.text)
         if error:
-            raise ErrorModelo(f"HF Space: {error}")
+            # El Space suele reportar aquí la cuota de ZeroGPU agotada; eso no se arregla
+            # reintentando (gastaría otra reserva del mismo pozo).
+            sin_cuota = bool(re.search(r"quota|gpu|exceed|limit", error, re.I))
+            raise ErrorModelo(
+                f"HF Space: {error}", reintentable=not sin_cuota, saturado=sin_cuota
+            )
         if texto is None:
             raise ErrorModelo("Sin respuesta del modelo (HF Space).")
 

backend/app/ai/medgemma.py

@@ -64,7 +64,11 @@ class MedGemmaClient:
             raise ErrorModelo(f"No se pudo conectar con medGemma en {self._url}: {exc}") from exc
 
         if resp.status_code >= 400:
-            raise ErrorModelo(f"medGemma devolvió HTTP {resp.status_code}: {resp.text[:200]}")
+            raise ErrorModelo(
+                f"medGemma devolvió HTTP {resp.status_code}: {resp.text[:200]}",
+                reintentable=resp.status_code >= 500,
+                saturado=resp.status_code == 429,
+            )
 
         contenido = resp.json().get("message", {}).get("content", "")
         try:

backend/app/ai/service.py

@@ -62,6 +62,11 @@ async def interpretar(pet: PeticionInterpretacion) -> RespuestaInterpretacion:
             break
         except ErrorModelo as exc:
             ultimo_error = exc
+            if not exc.reintentable:
+                # 429/cuota, rechazo por seguridad o configuración ausente: reintentar no puede
+                # ayudar y, en el caso de la cuota, gasta otra reserva de GPU del pozo agotado.
+                log.warning("Interpretación fallida sin reintento: %s", exc)
+                break
             log.warning("Interpretación fallida (intento %d): %s", intento + 1, exc)
 
     if resultado is None:

backend/app/config.py

@@ -107,6 +107,10 @@ class Configuracion(BaseSettings):
 
     # --- Rate limiting ---
     limite_interpret: str = Field(default="10/minute")
+    # Techo por USUARIO además del de IP. La cuota de ZeroGPU es por cuenta y compartida entre
+    # todos los veterinarios que usan la instancia pública: sin este límite, uno solo puede
+    # agotar la capacidad del día. Ajustar según la cuota real del plan.
+    limite_interpret_usuario: str = Field(default="20/hour")
     limite_login: str = Field(default="5/minute")
     limite_papers: str = Field(default="30/minute")
     limite_lab_ingesta: str = Field(default="120/minute")  # el analizador puede enviar en ráfaga

backend/app/routers/interpret.py

@@ -17,7 +17,7 @@ from ..ai.service import interpretar
 from ..config import obtener_config
 from ..schemas import PeticionInterpretacion, RespuestaInterpretacion
 from ..security.authz import usuario_actual, verificar_csrf
-from ..security.rate_limit import limiter
+from ..security.rate_limit import clave_usuario, limiter
 
 router = APIRouter()
 
@@ -44,6 +44,9 @@ def _validar_imagenes(imagenes: list[str]) -> None:
 
 @router.post("/interpret", response_model=RespuestaInterpretacion)
 @limiter.limit(obtener_config().limite_interpret)
+# Segundo límite, con clave por usuario: el de arriba (por IP) frena ráfagas puntuales, éste
+# impide que una sola cuenta consuma la cuota de GPU compartida a lo largo del día.
+@limiter.limit(obtener_config().limite_interpret_usuario, key_func=clave_usuario)
 async def post_interpret(
     request: Request,
     pet: PeticionInterpretacion,
@@ -54,4 +57,13 @@ async def post_interpret(
     try:
         return await interpretar(pet)
     except ErrorModelo as exc:
+        if exc.saturado:
+            # 503 + Retry-After y no 502: al cliente le sirve saber que es transitorio y cuándo
+            # reintentar. Un 502 genérico invita a recargar en bucle, que es lo peor que puede
+            # hacerse contra una cuota agotada.
+            raise HTTPException(
+                status.HTTP_503_SERVICE_UNAVAILABLE,
+                str(exc),
+                headers={"Retry-After": "300"},
+            ) from exc
         raise HTTPException(status.HTTP_502_BAD_GATEWAY, f"Error del modelo: {exc}") from exc

backend/app/security/rate_limit.py

@@ -7,7 +7,27 @@ Los límites concretos son configurables en config.py.
 
 from __future__ import annotations
 
+from fastapi import Request
 from slowapi import Limiter
 from slowapi.util import get_remote_address
 
+from .session import COOKIE_SESION, leer_sesion
+
 limiter = Limiter(key_func=get_remote_address)
+
+
+def clave_usuario(request: Request) -> str:
+    """Clave de rate limiting por USUARIO, no por IP.
+
+    En una herramienta gratuita el recurso escaso es la cuota de GPU compartida (ZeroGPU es por
+    cuenta, no por Space): un solo usuario puede agotarla para todos los demás. El límite por IP
+    no lo evita —una IP doméstica cambia, y varios veterinarios de una misma clínica comparten
+    IP, penalizándose entre sí—. Con la sesión como clave, el coste se imputa a quien lo genera.
+
+    Sin sesión se cae a la IP: /api/interpret exige sesión, así que ese caso sólo aparece si
+    cambia la guarda de auth.
+    """
+    sesion = leer_sesion(request.cookies.get(COOKIE_SESION))
+    if sesion and sesion.get("email"):
+        return f"user:{sesion['email']}"
+    return f"ip:{get_remote_address(request)}"

backend/tests/test_reintentos.py

@@ -0,0 +1,91 @@
+"""Política de reintentos del servicio de interpretación.
+
+El reintento existe para una sola cosa: la salida malformada de medGemma (razonamiento filtrado
+o bucle de repetición), donde volver a muestrear suele arreglarlo. Reintentar un 429 hace lo
+contrario —gasta otra reserva de GPU del mismo pozo agotado— y reintentar un rechazo por
+seguridad o una clave ausente no puede cambiar el resultado.
+
+Estos tests cuentan LLAMADAS, que es lo que consume cuota.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from app.ai import service
+from app.ai.base import ErrorModelo
+from app.schemas import InterpretacionClinica, PeticionInterpretacion
+
+PETICION = {
+    "paciente": {"especie": "canino"},
+    "hallazgos": [
+        {
+            "clave": "hct",
+            "nombre": "Hematocrito",
+            "valor": 22.0,
+            "unidad": "%",
+            "direccion": "bajo",
+            "gravedad": "grave",
+        }
+    ],
+    "patrones": [{"nombre": "Anemia", "descripcion": "…", "gravedad": "grave"}],
+    "imagenes": [],
+}
+
+
+class ClienteFalso:
+    nombre = "medgemma-hf"
+
+    def __init__(self, error: ErrorModelo | None, exito_en: int | None = None):
+        self.error = error
+        self.exito_en = exito_en
+        self.llamadas = 0
+
+    async def interpretar(self, *_a, **_k):
+        self.llamadas += 1
+        if self.exito_en is not None and self.llamadas >= self.exito_en:
+            return InterpretacionClinica(interpretacion="ok " * 20, requiere_derivacion=True)
+        raise self.error
+
+
+@pytest.fixture
+def sin_rag(monkeypatch):
+    """Aísla del retriever: estos tests miden reintentos, no recuperación."""
+    monkeypatch.setattr(service, "recuperar", lambda *_a, **_k: [])
+
+
+async def _interpretar_con(cliente, monkeypatch):
+    monkeypatch.setattr(service, "_crear_cliente", lambda _b: cliente)
+    return await service.interpretar(PeticionInterpretacion.model_validate(PETICION))
+
+
+async def test_saturado_no_se_reintenta(sin_rag, monkeypatch):
+    """El caso que motiva todo: un 429 debe costar UNA llamada, no dos."""
+    err = ErrorModelo("cuota agotada", reintentable=False, saturado=True)
+    cliente = ClienteFalso(err)
+    with pytest.raises(ErrorModelo) as exc:
+        await _interpretar_con(cliente, monkeypatch)
+    assert cliente.llamadas == 1, "un 429 reintentado duplica el gasto de cuota"
+    assert exc.value.saturado is True
+
+
+async def test_rechazo_de_seguridad_no_se_reintenta(sin_rag, monkeypatch):
+    cliente = ClienteFalso(ErrorModelo("rechazo", reintentable=False))
+    with pytest.raises(ErrorModelo):
+        await _interpretar_con(cliente, monkeypatch)
+    assert cliente.llamadas == 1
+
+
+async def test_salida_malformada_si_se_reintenta(sin_rag, monkeypatch):
+    """La razón de ser del reintento: se vuelve a muestrear y la segunda sale bien."""
+    cliente = ClienteFalso(ErrorModelo("razonamiento filtrado"), exito_en=2)
+    resultado = await _interpretar_con(cliente, monkeypatch)
+    assert cliente.llamadas == 2
+    assert resultado.resultado.interpretacion.startswith("ok")
+
+
+async def test_el_reintento_no_es_infinito(sin_rag, monkeypatch):
+    cliente = ClienteFalso(ErrorModelo("siempre malformada"))
+    with pytest.raises(ErrorModelo):
+        await _interpretar_con(cliente, monkeypatch)
+    assert cliente.llamadas == 2