sync: HF InferenceClient image generation fix

api/vision.py

@@ -18,7 +18,7 @@ Fallback chain analyze_image:
   3. HF BLIP VQA + captioning (richiede solo HF_TOKEN)
 
 Image generation and editing use exclusively Hugging Face Inference API:
-  - FLUX.1-schnell for text-to-image generation
+  - Stable Diffusion 3 Medium for text-to-image generation via HF Inference Providers
   - FLUX.1-Kontext-dev for prompt-guided image editing
 """
 import asyncio, base64, io, os, httpx, logging
@@ -35,11 +35,11 @@ _HF_API     = "https://router.huggingface.co/hf-inference"
 _USER_AGENT = "Mozilla/5.0 (compatible; AgenteAI/3.0)"
 
 _MODEL_MAP: dict[str, str] = {
-    "FLUX.1-schnell": "black-forest-labs/FLUX.1-schnell",
-    "FLUX.1-dev":     "black-forest-labs/FLUX.1-dev",
-    "sdxl":           "stabilityai/stable-diffusion-xl-base-1.0",
-    "flux":           "black-forest-labs/FLUX.1-schnell",
-    "flux-schnell":   "black-forest-labs/FLUX.1-schnell",
+    "FLUX.1-schnell": "stabilityai/stable-diffusion-3-medium-diffusers",
+    "FLUX.1-dev":     "stabilityai/stable-diffusion-3-medium-diffusers",
+    "sdxl":           "stabilityai/stable-diffusion-3-medium-diffusers",
+    "flux":           "stabilityai/stable-diffusion-3-medium-diffusers",
+    "flux-schnell":   "stabilityai/stable-diffusion-3-medium-diffusers",
 }
 
 _EDIT_MODEL = "timbrooks/instruct-pix2pix"
@@ -93,53 +93,33 @@ async def generate_image(req: GenerateImageRequest):
       - HF restituisce raw bytes PNG — non JSON.
       - steps ottimali FLUX.1-schnell: 4 (veloce) – 8 (qualità).
     """
-    model_id = _MODEL_MAP.get(req.model, "black-forest-labs/FLUX.1-schnell")
-    url      = f"{_HF_API}/models/{model_id}"
-
-    payload: dict = {"inputs": req.prompt.strip()[:400]}
-    params: dict = {"num_inference_steps": min(max(req.steps, 1), 8)}
-    if req.width  != 512: params["width"]  = min(max(req.width,  256), 1024)
-    if req.height != 512: params["height"] = min(max(req.height, 256), 1024)
-    if req.negative_prompt:
-        params["negative_prompt"] = req.negative_prompt[:200]
-    payload["parameters"] = params
-
-    async with httpx.AsyncClient(timeout=90) as client:
-        for attempt in range(2):
-            try:
-                r = await client.post(url, headers=_hf_headers(), json=payload)
+    model_id = _MODEL_MAP.get(req.model, "stabilityai/stable-diffusion-3-medium-diffusers")
+    prompt = req.prompt.strip()[:400]
+    steps = min(max(req.steps, 1), 8)
+    width = min(max(req.width, 256), 1024)
+    height = min(max(req.height, 256), 1024)
+
+    def _run_generation():
+        client = InferenceClient(token=os.getenv("HF_TOKEN"), provider="auto", timeout=90)
+        return client.text_to_image(
+            prompt=prompt,
+            model=model_id,
+            negative_prompt=req.negative_prompt[:200] if req.negative_prompt else None,
+            num_inference_steps=steps,
+            width=width,
+            height=height,
+        )
 
-                if r.status_code == 200:
-                    b64 = base64.b64encode(r.content).decode()
-                    return {
-                        "ok": True, "image_b64": b64, "mime": "image/png",
-                        "model": req.model, "prompt": req.prompt[:100],
-                    }
-
-                if r.status_code == 503 and attempt == 0:
-                    try:
-                        wait = min(float(r.json().get("estimated_time", 20)), 45)
-                    except Exception:
-                        wait = 20
-                    _logger.info("HF model loading, waiting %.0fs…", wait)
-                    await asyncio.sleep(wait)
-                    continue
-
-                try:
-                    err = r.json().get("error", r.text[:200])
-                except Exception:
-                    err = r.text[:200]
-                return {
-                    "ok": False, "error": f"HF API {r.status_code}: {err}",
-                    "hint": "Aggiungi HF_TOKEN nelle variabili d'ambiente per più richieste/ora.",
-                }
-
-            except httpx.TimeoutException:
-                return {"ok": False, "error": "Timeout 90s — modello in cold-start. Riprova tra 30s."}
-            except Exception as e:
-                return {"ok": False, "error": str(e)[:300]}
-
-    return {"ok": False, "error": "Impossibile generare dopo 2 tentativi."}
+    try:
+        generated = await asyncio.to_thread(_run_generation)
+        output = io.BytesIO()
+        generated.save(output, format="PNG")
+        return {"ok": True, "image_b64": base64.b64encode(output.getvalue()).decode(), "mime": "image/png", "model": model_id, "prompt": req.prompt[:100]}
+    except TimeoutError:
+        return {"ok": False, "error": "Timeout 90s — modello HF in cold-start. Riprova tra 30s."}
+    except Exception as e:
+        _logger.warning("HF image generation failed: %s", type(e).__name__)
+        return {"ok": False, "error": f"HF image generation unavailable: {str(e)[:300]}"}
 
 
 # ─── /edit ──────────────────────────────────────────��─────────────────────────

tests/test_vision_hf_only.py

@@ -63,16 +63,21 @@ def test_analyze_uses_hf_vqa_without_openai(monkeypatch):
 
 
 def test_generate_uses_huggingface(monkeypatch):
-    FakeClient.calls = []
-    FakeClient.responses = [FakeResponse(payload=None, content=b"generated-png")]
-    monkeypatch.setattr(vision.httpx, "AsyncClient", FakeClient)
+    class FakeInferenceClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def text_to_image(self, **kwargs):
+            assert kwargs["model"] == "stabilityai/stable-diffusion-3-medium-diffusers"
+            return Image.new("RGB", (1, 1), (0, 120, 255))
+
+    monkeypatch.setattr(vision, "InferenceClient", FakeInferenceClient)
 
     result = asyncio.run(vision.generate_image(vision.GenerateImageRequest(prompt="un paesaggio")))
 
     assert result["ok"] is True
     assert result["mime"] == "image/png"
-    assert result["image_b64"] == base64.b64encode(b"generated-png").decode()
-    assert "router.huggingface.co/hf-inference" in FakeClient.calls[0][0]
+    assert len(base64.b64decode(result["image_b64"])) > 0
 
 
 def test_edit_uses_inference_client_hf(monkeypatch):