vision + protocole: images, thinking adaptive, tool_choice none, plafond de sortie

anthropic_proxy.py

@@ -25,6 +25,10 @@ from fastapi.responses import JSONResponse, StreamingResponse
 UPSTREAM = os.environ.get("VL_UPSTREAM", "http://127.0.0.1:8080")
 MODEL = os.environ.get("VL_SERVED_NAME", "qwen")
 TIMEOUT = float(os.environ.get("VL_TIMEOUT", "1800"))
+# Sortie maximale du modele. Claude Code demande couramment 64 k, ce que
+# vLLM refuse d'un 400 portant sur max_tokens -- la requete entiere echoue
+# alors qu'un plafonnement silencieux suffit.
+MAX_OUTPUT = int(os.environ.get("VL_MAX_OUTPUT", "32768"))
 
 # Claude Code refuse tout identifiant de modele qui ne commence pas par
 # "claude-" : il valide le nom avant d'emettre la requete. On expose donc des
@@ -133,6 +137,33 @@ def guard_message(detail: str) -> str:
 
 # --------------------------------------------------------------- Anthropic -> OpenAI
 
+def _image_part(block: dict) -> dict | None:
+    """Traduit un bloc `image` Anthropic vers la partie `image_url` d'OpenAI.
+
+    Anthropic decrit l'image par une `source` typee : `base64` porte les octets
+    et le type MIME separement, `url` porte un lien. OpenAI attend dans les deux
+    cas UNE chaine dans `image_url.url` -- une URI de donnees pour le premier,
+    le lien tel quel pour le second.
+
+    Sans cette traduction, `_text_of` ignorait purement et simplement les blocs
+    image : une capture collee dans Claude Code arrivait au modele comme un
+    message vide, et le modele repondait a cote sans que rien ne signale la
+    perte.
+    """
+    src = block.get("source") or {}
+    kind = src.get("type")
+    if kind == "base64":
+        data = src.get("data")
+        if not data:
+            return None
+        mime = src.get("media_type") or "image/png"
+        return {"type": "image_url",
+                "image_url": {"url": f"data:{mime};base64,{data}"}}
+    if kind == "url" and src.get("url"):
+        return {"type": "image_url", "image_url": {"url": src["url"]}}
+    return None
+
+
 def _text_of(content: Any) -> str:
     """Anthropic autorise une chaine ou une liste de blocs typés."""
     if isinstance(content, str):
@@ -186,13 +217,17 @@ def to_openai(body: dict) -> dict:
             # Un tour d'assistant peut melanger du texte et des tool_use ; un tour
             # d'utilisateur porte les tool_result. OpenAI separe les deux en
             # `tool_calls` sur l'assistant et en messages de role `tool`.
-            texts, calls, results = [], [], []
+            texts, calls, results, images = [], [], [], []
             for b in content:
                 if not isinstance(b, dict):
                     continue
                 t = b.get("type")
                 if t == "text":
                     texts.append(b.get("text", ""))
+                elif t == "image":
+                    part = _image_part(b)
+                    if part:
+                        images.append(part)
                 elif t == "tool_use":
                     calls.append({
                         "id": b.get("id") or f"call_{uuid.uuid4().hex[:8]}",
@@ -203,10 +238,21 @@ def to_openai(body: dict) -> dict:
                         },
                     })
                 elif t == "tool_result":
+                    # Un resultat d'outil peut porter des images (capture rendue
+                    # par un outil). Le role `tool` d'OpenAI n'accepte que du
+                    # texte : on extrait les images pour les rattacher au tour
+                    # utilisateur, sinon elles disparaissent en silence.
+                    rc = b.get("content")
+                    if isinstance(rc, list):
+                        for sub in rc:
+                            if isinstance(sub, dict) and sub.get("type") == "image":
+                                part = _image_part(sub)
+                                if part:
+                                    images.append(part)
                     results.append({
                         "role": "tool",
                         "tool_call_id": b.get("tool_use_id", ""),
-                        "content": _text_of(b.get("content")) or "",
+                        "content": _text_of(rc) or "",
                     })
 
             if role == "assistant":
@@ -215,7 +261,16 @@ def to_openai(body: dict) -> dict:
                     a["tool_calls"] = calls
                 msgs.append(a)
             else:
-                if texts:
+                if images:
+                    # Contenu multipart : OpenAI n'accepte les images que dans
+                    # une LISTE de parties, jamais dans une chaine.
+                    parts: list[dict] = []
+                    joined = "".join(texts)
+                    if joined:
+                        parts.append({"type": "text", "text": joined})
+                    parts.extend(images)
+                    msgs.append({"role": "user", "content": parts})
+                elif texts:
                     msgs.append({"role": "user", "content": "".join(texts)})
                 msgs.extend(results)
         else:
@@ -224,7 +279,7 @@ def to_openai(body: dict) -> dict:
     out: dict[str, Any] = {
         "model": MODEL,
         "messages": msgs,
-        "max_tokens": body.get("max_tokens", 4096),
+        "max_tokens": min(int(body.get("max_tokens") or 4096), MAX_OUTPUT),
         "stream": bool(body.get("stream")),
     }
     for src, dst in (("temperature", "temperature"), ("top_p", "top_p"),
@@ -239,6 +294,12 @@ def to_openai(body: dict) -> dict:
     # sous la forme enable_thinking=false, qui fait prefixer un bloc <think> deja
     # ferme. Sans cette traduction, le champ etait recu puis ignore en silence :
     # la case "raisonnement" de la console ne changeait rien.
+    # `thinking` a plusieurs formes. La documentation du protocole de passerelle
+    # precise que Claude Code envoie `{"type": "adaptive"}` aux modeles recents
+    # ET "traite les noms de modeles qu'il ne reconnait pas, tels les alias de
+    # passerelle, comme des modeles actuels qui recoivent le champ" -- donc nous.
+    # Seul "disabled" doit couper le raisonnement ; "adaptive" et "enabled" le
+    # laissent actif, qui est le defaut du gabarit.
     th = body.get("thinking")
     if isinstance(th, dict) and th.get("type") == "disabled":
         out["chat_template_kwargs"] = {"enable_thinking": False}
@@ -254,7 +315,9 @@ def to_openai(body: dict) -> dict:
         } for t in body["tools"] if t.get("name")]
         tc = body.get("tool_choice") or {}
         kind = tc.get("type") if isinstance(tc, dict) else None
-        if kind == "any":
+        if kind == "none":
+            out["tool_choice"] = "none"
+        elif kind == "any":
             out["tool_choice"] = "required"
         elif kind == "tool" and tc.get("name"):
             out["tool_choice"] = {"type": "function", "function": {"name": tc["name"]}}