protocole passerelle: erreurs amont intactes (reprise auto) + decouverte sous 3s

anthropic_proxy.py

@@ -323,6 +323,21 @@ def to_anthropic(oai: dict, req_model: str) -> dict:
     }
 
 
+def _err_of(body: str, status: int) -> dict:
+    """Renvoie l'objet d'erreur amont intact, ou en fabrique un equivalent.
+
+    Le libelle compte : c'est sur lui que le client decide s'il peut retenter.
+    """
+    try:
+        d = json.loads(body)
+        e = d.get("error")
+        if isinstance(e, dict) and e.get("message"):
+            return {"type": e.get("type") or "api_error", "message": e["message"]}
+    except (json.JSONDecodeError, AttributeError):
+        pass
+    return {"type": "api_error", "message": body or f"upstream {status}"}
+
+
 def _sse(event: str, data: dict) -> bytes:
     return f"event: {event}\ndata: {json.dumps(data, separators=(',', ':'))}\n\n".encode()
 
@@ -384,22 +399,16 @@ async def stream_anthropic(payload: dict, req_model: str):
             roles = "/".join(m.get("role", "?") for m in payload.get("messages", []))
             print(f"[amont {r.status_code}] {body}", flush=True)
             print(f"[amont] roles={roles}", flush=True)
-            idx += 1
-            yield _sse("content_block_start", {
-                "type": "content_block_start", "index": idx,
-                "content_block": {"type": "text", "text": ""}})
-            yield _sse("content_block_delta", {
-                "type": "content_block_delta", "index": idx,
-                "delta": {"type": "text_delta",
-                          "text": "[pont] vLLM a refuse la requete "
-                                  f"({r.status_code}) :\n{body}"}})
-            yield _sse("content_block_stop",
-                       {"type": "content_block_stop", "index": idx})
-            yield _sse("message_delta", {
-                "type": "message_delta",
-                "delta": {"stop_reason": "end_turn", "stop_sequence": None},
-                "usage": {"input_tokens": 0, "output_tokens": 0}})
-            yield _sse("message_stop", {"type": "message_stop"})
+            # Le corps d'erreur repart TEL QUEL, dans un evenement SSE `error`.
+            # La documentation du protocole de passerelle est explicite : Claude
+            # Code se remet tout seul de certains refus -- champ `thinking`,
+            # signatures de raisonnement, et justement les messages systeme en
+            # milieu de conversation -- mais "la logique de reprise s'appuie sur
+            # le libelle de l'erreur amont", et "une passerelle qui enveloppe
+            # les erreurs dans son propre format casse la reprise meme si elle
+            # preserve le code de statut". Emballer l'erreur dans un bloc texte,
+            # comme je le faisais, empechait donc cette reprise.
+            yield _sse("error", {"type": "error", "error": _err_of(body, r.status_code)})
             return
         async for line in r.aiter_lines():
             if not line.startswith("data: "):
@@ -612,7 +621,7 @@ async def models(request: Request):
     """
     if "anthropic-version" not in request.headers:
         try:
-            r = await _client.get("/v1/models", timeout=10)
+            r = await _client.get("/v1/models", timeout=2.0)
             if r.status_code == 200:
                 return JSONResponse(r.json())
         except Exception:
@@ -620,7 +629,7 @@ async def models(request: Request):
 
     ctx = None
     try:
-        r = await _client.get("/v1/models", timeout=10)
+        r = await _client.get("/v1/models", timeout=2.0)
         if r.status_code == 200:
             ctx = (r.json().get("data") or [{}])[0].get("max_model_len")
     except Exception: