sync: force deploy vision HF-only from origin/main

api/vision.py

@@ -3,21 +3,26 @@ vision.py — Generazione e analisi immagini + ricerca immagini.
 
 Endpoints:
   POST /api/vision/generate  — FLUX.1-schnell (HF Inference API)
-  POST /api/vision/analyze   — Groq llama-3.2-vision / GPT-4o-mini / BLIP fallback
+  POST /api/vision/analyze   — Groq llama-3.2-vision / Gemini Vision / HF VQA + BLIP fallback
   GET  /api/vision/search    — Pexels > Pixabay > Unsplash Source (zero API key)
 
 Problematiche HF Inference API:
   - 503 "loading": cold-start fino a 60s → retry con backoff
   - Output generate: raw bytes PNG (non JSON)
-  - BLIP: captioning solo, non risponde a domande aperte
+  - BLIP VQA risponde a domande semplici; BLIP captioning fornisce una didascalia di fallback
   - Rate limit senza HF_TOKEN: ~10 req/hr per IP
 
 Fallback chain analyze_image:
   1. Groq llama-3.2-11b-vision-preview (free tier, veloce, richiede GROQ_API_KEY)
-  2. GPT-4o-mini vision (richiede OPENAI_API_KEY)
-  3. BLIP-large captioning (HF Inference, libero ma solo didascalia)
+  2. Gemini 2.5 Flash Vision (free tier, richiede GEMINI_API_KEY)
+  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
+  - FLUX.1-Kontext-dev for prompt-guided image editing
 """
-import asyncio, base64, os, httpx, logging
+import asyncio, base64, io, os, httpx, logging
+from huggingface_hub import InferenceClient
 from fastapi import APIRouter, Depends
 from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
@@ -25,7 +30,8 @@ from pydantic import BaseModel
 router  = APIRouter(prefix="/api/vision", tags=["vision"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("vision")
 
-_HF_API     = "https://api-inference.huggingface.co"
+# Router Inference Providers: l’host api-inference legacy non è più disponibile.
+_HF_API     = "https://router.huggingface.co/hf-inference"
 _USER_AGENT = "Mozilla/5.0 (compatible; AgenteAI/3.0)"
 
 _MODEL_MAP: dict[str, str] = {
@@ -36,6 +42,10 @@ _MODEL_MAP: dict[str, str] = {
     "flux-schnell":   "black-forest-labs/FLUX.1-schnell",
 }
 
+_EDIT_MODEL = "timbrooks/instruct-pix2pix"
+_HF_VQA_MODEL = "Salesforce/blip-vqa-base"
+_HF_CAPTION_MODEL = "Salesforce/blip-image-captioning-large"
+
 
 def _hf_headers(content_type: str = "application/json") -> dict:
     token = os.getenv("HF_TOKEN", "")
@@ -63,6 +73,13 @@ class AnalyzeImageRequest(BaseModel):
     question:     str = "Descrivi questa immagine in dettaglio in italiano."
 
 
+class EditImageRequest(BaseModel):
+    prompt:          str
+    base64_image:    str
+    negative_prompt: str = ""
+    steps:           int = 5
+
+
 # ─── /generate ────────────────────────────────────────────────────────────────
 
 @router.post("/generate")
@@ -125,6 +142,37 @@ async def generate_image(req: GenerateImageRequest):
     return {"ok": False, "error": "Impossibile generare dopo 2 tentativi."}
 
 
+# ─── /edit ────────────────────────────────────────────────────────────────────
+
+@router.post("/edit")
+async def edit_image(req: EditImageRequest):
+    """Modifica un’immagine con un provider Hugging Face selezionato automaticamente."""
+    try:
+        source = base64.b64decode(req.base64_image)
+        prompt = req.prompt.strip()[:400]
+        steps = min(max(req.steps, 1), 8)
+
+        def _run_edit():
+            client = InferenceClient(token=os.getenv("HF_TOKEN"), provider="auto", timeout=120)
+            return client.image_to_image(
+                image=source,
+                prompt=prompt,
+                model="black-forest-labs/FLUX.1-Kontext-dev",
+                negative_prompt=req.negative_prompt[:200] if req.negative_prompt else None,
+                num_inference_steps=steps,
+            )
+
+        edited = await asyncio.to_thread(_run_edit)
+        output = io.BytesIO()
+        edited.save(output, format="PNG")
+        return {"ok": True, "image_b64": base64.b64encode(output.getvalue()).decode(), "mime": "image/png", "model": "FLUX.1-Kontext-dev"}
+    except TimeoutError:
+        return {"ok": False, "error": "Timeout 120s — modello image-to-image in cold-start."}
+    except Exception as e:
+        _logger.warning("HF image edit failed: %s", type(e).__name__)
+        return {"ok": False, "error": f"HF image edit unavailable: {str(e)[:300]}"}
+
+
 # ─── /analyze ─────────────────────────────────────────────────────────────────
 
 @router.post("/analyze")
@@ -134,8 +182,8 @@ async def analyze_image(req: AnalyzeImageRequest):
 
     Chain:
       1. Groq llama-3.2-11b-vision (free tier, 30 img/min)
-      2. GPT-4o-mini vision
-      3. BLIP-large captioning (HF, puro captioning senza Q&A)
+      2. Gemini 2.5 Flash Vision (free tier)
+      3. HF BLIP VQA, poi BLIP-large captioning
     """
     # Scarica immagine se URL
     image_b64  = req.base64_image
@@ -185,8 +233,8 @@ async def analyze_image(req: AnalyzeImageRequest):
             _logger.debug("analyze_image: groq vision failed (%s)", type(_e).__name__)
 
     # 2. Gemini Vision (free tier — GEMINI_API_KEY da aistudio.google.com)
-    # GAP-TOOL-2-fix: Gemini 1.5 Flash supporta vision, è gratuito su AI Studio, non richiede dominio.
-    # Inserito prima di GPT-4o-mini (paid) come primo fallback gratuito di Groq.
+    # Gemini 2.5 Flash supporta vision ed è disponibile nel tier gratuito AI Studio.
+    # Viene usato come fallback gratuito dopo Groq.
     _gemini_key = os.getenv("GEMINI_API_KEY", "")
     if _gemini_key:
         try:
@@ -214,32 +262,32 @@ async def analyze_image(req: AnalyzeImageRequest):
         except Exception as _e:
             _logger.debug("analyze_image: gemini vision failed (%s)", type(_e).__name__)
 
-    # 3. OpenAI GPT-4o-mini vision
-    _openai_key  = os.getenv("OPENAI_API_KEY", "")
-    _openai_base = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/")
-    if _openai_key:
-        try:
-            async with httpx.AsyncClient(timeout=30) as c:
-                r = await c.post(
-                    f"{_openai_base}/chat/completions",
-                    headers={"Authorization": f"Bearer {_openai_key}", "Content-Type": "application/json"},
-                    json={"model": "gpt-4o-mini", "max_tokens": 600, "messages": vision_body_msgs},
-                )
-                if r.status_code == 200:
-                    # S750-GAP-H: guard choices[] — provider può ritornare {"error":...}
-                    _chs2 = r.json().get("choices") or []
-                    _desc2 = (_chs2[0].get("message",{}).get("content") or "") if _chs2 else ""
-                    if _desc2:
-                        return {"ok": True, "description": _desc2, "provider": "gpt-4o-mini"}
-        except Exception as _e:
-            _logger.debug("analyze_image: openai vision failed (%s)", type(_e).__name__)
+    # 3. Hugging Face BLIP VQA (Q&A) e captioning (fallback senza provider a pagamento)
+    try:
+        async with httpx.AsyncClient(timeout=45) as c:
+            vqa = await c.post(
+                f"{_HF_API}/models/{_HF_VQA_MODEL}",
+                headers=_hf_headers(),
+                json={"inputs": {"image": image_b64, "question": question}},
+            )
+            if vqa.status_code == 200:
+                results = vqa.json()
+                answer = ""
+                if isinstance(results, list) and results:
+                    answer = str(results[0].get("answer", "") or results[0].get("generated_text", ""))
+                elif isinstance(results, dict):
+                    answer = str(results.get("answer", "") or results.get("generated_text", ""))
+                if answer.strip():
+                    return {"ok": True, "description": answer.strip(), "provider": "blip-vqa"}
+    except Exception as _e:
+        _logger.debug("analyze_image: HF VQA failed (%s)", type(_e).__name__)
 
-    # 4. HF BLIP-large (captioning only — ultimo fallback)
+    # 4. HF BLIP-large captioning (ultimo fallback)
     try:
         img_bytes = base64.b64decode(image_b64)
         async with httpx.AsyncClient(timeout=30) as c:
             r = await c.post(
-                f"{_HF_API}/models/Salesforce/blip-image-captioning-large",
+                f"{_HF_API}/models/{_HF_CAPTION_MODEL}",
                 headers={k: v for k, v in _hf_headers("application/octet-stream").items()},
                 content=img_bytes,
             )
@@ -247,9 +295,7 @@ async def analyze_image(req: AnalyzeImageRequest):
                 results = r.json()
                 caption = (results[0].get("generated_text", "") if isinstance(results, list) and results else "")
                 if caption:
-                    note = ("\n\n_BLIP fornisce solo didascalia base. Per Q&A su immagini, "
-                            "aggiungi GROQ_API_KEY (gratuito su console.groq.com)._")
-                    return {"ok": True, "description": caption + note, "provider": "blip-large"}
+                    return {"ok": True, "description": caption, "provider": "blip-large"}
             elif r.status_code == 503:
                 return {"ok": False, "error": "BLIP in avvio (cold-start ~30s). Riprova tra qualche secondo.",
                         "hint": "Aggiungi GROQ_API_KEY per analisi rapida e senza limiti di cold-start."}
@@ -258,8 +304,7 @@ async def analyze_image(req: AnalyzeImageRequest):
 
     return {
         "ok": False, "error": "Analisi immagini non disponibile.",
-        "hint": ("Aggiungi GROQ_API_KEY (free su console.groq.com) o OPENAI_API_KEY "
-                 "nelle variabili del tuo HF Space."),
+        "hint": "Configura HF_TOKEN per il fallback Hugging Face oppure un provider gratuito Groq/Gemini.",
     }
 
 

tests/test_vision_hf_only.py

@@ -0,0 +1,96 @@
+import asyncio
+import base64
+import sys
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from api import vision
+
+
+class FakeResponse:
+    def __init__(self, status_code=200, payload=None, content=b"png-bytes", text=""):
+        self.status_code = status_code
+        self._payload = payload
+        self.content = content
+        self.text = text
+
+    def json(self):
+        if isinstance(self._payload, Exception):
+            raise self._payload
+        return self._payload
+
+
+class FakeClient:
+    calls = []
+    responses = []
+
+    def __init__(self, *args, **kwargs):
+        self.calls = []
+
+    async def __aenter__(self):
+        FakeClient.active = self
+        return self
+
+    async def __aexit__(self, *args):
+        return False
+
+    async def post(self, url, **kwargs):
+        self.calls.append((url, kwargs))
+        FakeClient.calls.append((url, kwargs))
+        return FakeClient.responses.pop(0)
+
+
+def test_analyze_uses_hf_vqa_without_openai(monkeypatch):
+    FakeClient.calls = []
+    FakeClient.responses = [FakeResponse(payload=[{"answer": "un gatto"}])]
+    monkeypatch.setattr(vision.httpx, "AsyncClient", FakeClient)
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
+    monkeypatch.delenv("GROQ_API_KEY", raising=False)
+    monkeypatch.delenv("GEMINI_API_KEY", raising=False)
+
+    result = asyncio.run(vision.analyze_image(
+        vision.AnalyzeImageRequest(base64_image=base64.b64encode(b"image").decode(), question="Cosa vedi?")
+    ))
+
+    assert result == {"ok": True, "description": "un gatto", "provider": "blip-vqa"}
+    assert len(FakeClient.calls) == 1
+    assert vision._HF_VQA_MODEL in FakeClient.calls[0][0]
+    assert all("openai.com" not in call[0] for call in FakeClient.calls)
+
+
+def test_generate_uses_huggingface(monkeypatch):
+    FakeClient.calls = []
+    FakeClient.responses = [FakeResponse(payload=None, content=b"generated-png")]
+    monkeypatch.setattr(vision.httpx, "AsyncClient", FakeClient)
+
+    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]
+
+
+def test_edit_uses_inference_client_hf(monkeypatch):
+    class FakeInferenceClient:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+        def image_to_image(self, **kwargs):
+            assert kwargs["model"] == "black-forest-labs/FLUX.1-Kontext-dev"
+            return Image.new("RGB", (1, 1), (0, 120, 255))
+
+    monkeypatch.setattr(vision, "InferenceClient", FakeInferenceClient)
+
+    result = asyncio.run(vision.edit_image(
+        vision.EditImageRequest(prompt="rendi il cielo blu", base64_image="aW1hZ2U=")
+    ))
+
+    assert result["ok"] is True
+    assert result["model"] == "FLUX.1-Kontext-dev"
+    assert result["mime"] == "image/png"
+    assert len(base64.b64decode(result["image_b64"])) > 0