sync: 183 file da Baida98/AI@1dcbd977 (2026-08-25 15:06 UTC) [deploy-all] (#50)

- sync: 183 file da Baida98/AI@1dcbd977 (2026-08-25 15:06 UTC) [deploy-all] (042b26ac5db4395f2676b269717991e332b12148)

agents/unified_loop_tools.py

@@ -360,20 +360,24 @@ class DirectToolsMixin:
                 _sc = _spec_hit("generate_image", {"prompt": _img_prompt[:600]})
                 if _sc is not None:
                     return _sc
-                # Pollinations genera l'immagine quando il browser richiede questo
-                # URL. Costruirlo qui rende il direct tool autosufficiente: non
-                # dipende da cold-start HF, dal contratto base64 dell'endpoint
-                # vision né da un provider LLM per verbalizzare il risultato.
-                from urllib.parse import quote
                 _img_prompt = _img_prompt[:600]
-                _img_seed = sum(ord(char) for char in _img_prompt) % 9999 + 1
-                img_url = (
-                    f"https://image.pollinations.ai/prompt/{quote(_img_prompt, safe='')}"
-                    f"?width=512&height=512&seed={_img_seed}&nologo=true&enhance=true"
-                )
-                # L'URL viene materializzato dal client nel VFS come data URI JPEG
-                # durante il commit atomico del task. Il nome è derivato dal prompt
-                # normalizzato: è sicuro, ripetibile e non contiene input utente.
+                # Il provider autenticato rimane lato server. Il fallback storico
+                # resta solo per garantire la creazione gratuita se il secret non è
+                # ancora disponibile durante un riavvio del runtime.
+                try:
+                    from api.image_provider import generate_pollinations_image
+                    remote = await generate_pollinations_image(_img_prompt, width=512, height=512)
+                    img_url = remote.url
+                    img_mime = remote.mime_type
+                except Exception as provider_exc:
+                    _logger.info("image provider unavailable; using free URL fallback (%s)", type(provider_exc).__name__)
+                    from urllib.parse import quote
+                    _img_seed = sum(ord(char) for char in _img_prompt) % 9999 + 1
+                    img_url = (
+                        f"https://image.pollinations.ai/prompt/{quote(_img_prompt, safe='')}"
+                        f"?width=512&height=512&seed={_img_seed}&nologo=true&enhance=true"
+                    )
+                    img_mime = "image/jpeg"
                 _artifact_id = hashlib.sha256(_img_prompt.encode("utf-8")).hexdigest()[:12]
                 _artifact_path = f"generated-image-{_artifact_id}.jpg"
                 if on_step:
@@ -382,7 +386,7 @@ class DirectToolsMixin:
                         "status": "done",
                         "path": _artifact_path,
                         "source_url": img_url,
-                        "mime_type": "image/jpeg",
+                        "mime_type": img_mime,
                         "title": "Immagine salvata nel workspace",
                         "explanation": f"Salvo {_artifact_path} nel VFS…",
                     }))

api/agent.py

@@ -1232,7 +1232,12 @@ async def stream_agent_task(task_id: str, request: Request, resume: int = 0, rol
                         elif _action == 'file_written':
                             _source_url = str(step_data.get('source_url') or '')
                             _mime_type = str(step_data.get('mime_type') or '')
-                            if (_source_url.startswith('https://image.pollinations.ai/') and
+                            _allowed_image_origins = (
+                                'https://image.pollinations.ai/',
+                                'https://media.pollinations.ai/',
+                                'https://gen.pollinations.ai/',
+                            )
+                            if (_source_url.startswith(_allowed_image_origins) and
                                     _mime_type in {'image/jpeg', 'image/png', 'image/webp'}):
                                 _vfs_evt['sourceUrl'] = _source_url[:2_000]
                                 _vfs_evt['mimeType'] = _mime_type

api/image_provider.py

@@ -0,0 +1,226 @@
+"""Adapter server-side per la generazione e modifica immagini.
+
+Le credenziali del provider restano esclusivamente in ``POLLINATIONS_API_KEY``.
+Il modulo restituisce solo URL HTTPS Pollinations validati: nessun token o byte immagine
+viene inoltrato attraverso SSE.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import random
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+POLLINATIONS_BASE_URL = "https://gen.pollinations.ai"
+_ALLOWED_HOSTS = {"gen.pollinations.ai", "image.pollinations.ai", "media.pollinations.ai"}
+_TRANSIENT_STATUS_CODES = {429, 500, 502, 503, 504}
+_MAX_PROMPT_CHARS = 1_200
+
+
+@dataclass(frozen=True)
+class RemoteImage:
+    """Riferimento remoto sicuro da materializzare lato client nel VFS."""
+
+    url: str
+    mime_type: str
+    provider: str = "pollinations"
+    revised_prompt: str | None = None
+
+
+class ImageProviderError(RuntimeError):
+    """Errore sicuro da esporre al chiamante senza leak di segreti provider."""
+
+    def __init__(self, message: str, *, status_code: int | None = None, retry_after: float | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.retry_after = retry_after
+
+
+def is_pollinations_remote_url(value: str) -> bool:
+    """Accetta solo URL HTTPS del dominio Pollinations controllato dal provider."""
+    try:
+        parsed = urlparse(value)
+    except ValueError:
+        return False
+    host = (parsed.hostname or "").lower().rstrip(".")
+    return (
+        parsed.scheme == "https"
+        and bool(parsed.path)
+        and host in _ALLOWED_HOSTS
+    )
+
+
+def _provider_key() -> str:
+    value = os.getenv("POLLINATIONS_API_KEY", "").strip()
+    if not value:
+        raise ImageProviderError("Il provider immagini server-side non è configurato.")
+    return value
+
+
+def _bounded_prompt(value: str) -> str:
+    prompt = value.strip()
+    if not prompt:
+        raise ImageProviderError("Il prompt dell’immagine è obbligatorio.", status_code=400)
+    return prompt[:_MAX_PROMPT_CHARS]
+
+
+def _retry_after(response: httpx.Response) -> float | None:
+    raw = response.headers.get("retry-after", "").strip()
+    try:
+        seconds = float(raw)
+    except ValueError:
+        return None
+    return max(0.0, min(seconds, 30.0))
+
+
+def _read_remote_image(payload: dict[str, Any]) -> RemoteImage:
+    items = payload.get("data")
+    first = items[0] if isinstance(items, list) and items else None
+    url = first.get("url") if isinstance(first, dict) else None
+    if not isinstance(url, str) or not is_pollinations_remote_url(url):
+        raise ImageProviderError("Il provider non ha restituito un URL immagine sicuro.")
+    mime = first.get("media_type") if isinstance(first, dict) else None
+    revised_prompt = first.get("revised_prompt") if isinstance(first, dict) else None
+    return RemoteImage(
+        url=url,
+        mime_type=mime if isinstance(mime, str) and mime.startswith("image/") else "image/jpeg",
+        revised_prompt=revised_prompt if isinstance(revised_prompt, str) else None,
+    )
+
+
+async def _post_image_operation(path: str, payload: dict[str, Any], *, timeout_seconds: float) -> RemoteImage:
+    """Esegue una richiesta provider con un solo retry per errori realmente transitori."""
+    headers = {
+        "Authorization": f"Bearer {_provider_key()}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "User-Agent": "AgenteAI/3.4 image-provider",
+    }
+    async with httpx.AsyncClient(timeout=httpx.Timeout(timeout_seconds), follow_redirects=False) as client:
+        for attempt in range(2):
+            try:
+                response = await client.post(f"{POLLINATIONS_BASE_URL}{path}", headers=headers, json=payload)
+            except httpx.TimeoutException as exc:
+                if attempt == 0:
+                    await asyncio.sleep(0.5 + random.uniform(0.0, 0.25))
+                    continue
+                raise ImageProviderError("Il provider immagini non ha risposto entro il tempo previsto.") from exc
+            except httpx.HTTPError as exc:
+                if attempt == 0:
+                    await asyncio.sleep(0.5 + random.uniform(0.0, 0.25))
+                    continue
+                raise ImageProviderError("Il provider immagini non è raggiungibile.") from exc
+
+            if response.status_code == 200:
+                try:
+                    return _read_remote_image(response.json())
+                except ValueError as exc:
+                    raise ImageProviderError("Il provider ha restituito una risposta immagine non valida.") from exc
+
+            retry_after = _retry_after(response)
+            if response.status_code in _TRANSIENT_STATUS_CODES and attempt == 0:
+                await asyncio.sleep(retry_after if retry_after is not None else 0.75 + random.uniform(0.0, 0.25))
+                continue
+
+            message_by_status = {
+                400: "La richiesta immagine non è valida.",
+                401: "Il provider immagini non è autenticato correttamente.",
+                402: "Il credito del provider immagini non è disponibile.",
+                403: "Il provider immagini non autorizza questo modello o questa operazione.",
+                429: "Il provider immagini è temporaneamente soggetto a rate limit.",
+            }
+            raise ImageProviderError(
+                message_by_status.get(response.status_code, "Il provider immagini ha restituito un errore."),
+                status_code=response.status_code,
+                retry_after=retry_after,
+            )
+
+    raise ImageProviderError("Il provider immagini non ha prodotto alcun risultato.")
+
+
+async def generate_pollinations_image(prompt: str, *, width: int = 1024, height: int = 1024) -> RemoteImage:
+    """Genera una singola immagine remota, senza serializzare l’immagine nella chat/SSE."""
+    safe_width = min(max(int(width), 256), 1024)
+    safe_height = min(max(int(height), 256), 1024)
+    return await _post_image_operation(
+        "/v1/images/generations",
+        {
+            "prompt": _bounded_prompt(prompt),
+            "model": "flux",
+            "n": 1,
+            "size": f"{safe_width}x{safe_height}",
+            "quality": "medium",
+            "response_format": "url",
+            "safe": True,
+        },
+        timeout_seconds=55,
+    )
+
+
+async def edit_pollinations_image(
+    prompt: str,
+    *,
+    source_bytes: bytes,
+    source_mime: str = "image/jpeg",
+) -> RemoteImage:
+    """Modifica un artefatto VFS inviandolo al provider come multipart/form-data."""
+    if not source_bytes or len(source_bytes) > 5 * 1024 * 1024:
+        raise ImageProviderError("L’immagine di origine deve avere una dimensione compresa tra 1 byte e 5 MB.", status_code=400)
+    if source_mime not in {"image/jpeg", "image/png", "image/webp"}:
+        raise ImageProviderError("Il formato dell’immagine di origine non è supportato.", status_code=400)
+
+    extension = {"image/jpeg": "jpg", "image/png": "png", "image/webp": "webp"}[source_mime]
+    data = {
+        "prompt": _bounded_prompt(prompt),
+        "model": "flux",
+        "n": "1",
+        "response_format": "url",
+        "safe": "true",
+    }
+    headers = {
+        "Authorization": f"Bearer {_provider_key()}",
+        "Accept": "application/json",
+        "User-Agent": "AgenteAI/3.4 image-provider",
+    }
+    async with httpx.AsyncClient(timeout=httpx.Timeout(70), follow_redirects=False) as client:
+        for attempt in range(2):
+            try:
+                response = await client.post(
+                    f"{POLLINATIONS_BASE_URL}/v1/images/edits",
+                    headers=headers,
+                    data=data,
+                    files={"image": (f"source.{extension}", source_bytes, source_mime)},
+                )
+            except httpx.TimeoutException as exc:
+                if attempt == 0:
+                    await asyncio.sleep(0.5 + random.uniform(0.0, 0.25))
+                    continue
+                raise ImageProviderError("Il provider immagini non ha risposto entro il tempo previsto.") from exc
+            except httpx.HTTPError as exc:
+                if attempt == 0:
+                    await asyncio.sleep(0.5 + random.uniform(0.0, 0.25))
+                    continue
+                raise ImageProviderError("Il provider immagini non è raggiungibile.") from exc
+
+            if response.status_code == 200:
+                try:
+                    return _read_remote_image(response.json())
+                except ValueError as exc:
+                    raise ImageProviderError("Il provider ha restituito una risposta immagine non valida.") from exc
+            retry_after = _retry_after(response)
+            if response.status_code in _TRANSIENT_STATUS_CODES and attempt == 0:
+                await asyncio.sleep(retry_after if retry_after is not None else 0.75 + random.uniform(0.0, 0.25))
+                continue
+            message_by_status = {
+                400: "La richiesta di modifica immagine non è valida.",
+                401: "Il provider immagini non è autenticato correttamente.",
+                402: "Il credito del provider immagini non è disponibile.",
+                403: "Il provider immagini non autorizza questa modifica.",
+                429: "Il provider immagini è temporaneamente soggetto a rate limit.",
+            }
+            raise ImageProviderError(message_by_status.get(response.status_code, "Il provider immagini ha restituito un errore."), status_code=response.status_code, retry_after=retry_after)
+    raise ImageProviderError("Il provider immagini non ha prodotto alcun risultato.")

api/vision.py

@@ -26,6 +26,7 @@ from huggingface_hub import InferenceClient
 from fastapi import APIRouter, Depends
 from .auth_guard import require_role, AuthRole
 from pydantic import BaseModel
+from .image_provider import ImageProviderError, edit_pollinations_image, generate_pollinations_image
 
 router  = APIRouter(prefix="/api/vision", tags=["vision"], dependencies=[Depends(require_role(AuthRole.MACHINE))])  # GAP-1-fix: router-level auth
 _logger = logging.getLogger("vision")
@@ -76,6 +77,7 @@ class AnalyzeImageRequest(BaseModel):
 class EditImageRequest(BaseModel):
     prompt:          str
     base64_image:    str
+    mime_type:       str = "image/jpeg"
     negative_prompt: str = ""
     steps:           int = 5
 
@@ -99,58 +101,35 @@ async def generate_image(req: GenerateImageRequest):
     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,
-        )
-
     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]}"}
+        remote = await generate_pollinations_image(prompt, width=width, height=height)
+        return {"ok": True, "image_url": remote.url, "mime": remote.mime_type,
+                "provider": remote.provider, "prompt": req.prompt[:100],
+                "revised_prompt": remote.revised_prompt}
+    except ImageProviderError as exc:
+        return {"ok": False, "error": str(exc), "status_code": exc.status_code,
+                "retry_after": exc.retry_after}
 
 
 # ─── /edit ────────────────────────────────────────────────────────────────────
 
 @router.post("/edit")
 async def edit_image(req: EditImageRequest):
-    """Modifica un’immagine con un provider Hugging Face selezionato automaticamente."""
+    """Modifica un file immagine VFS con il provider gratuito server-side."""
     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]}"}
+        raw = req.base64_image.strip()
+        if raw.startswith("data:"):
+            header, _, raw = raw.partition(",")
+            req.mime_type = header[5:].split(";", 1)[0] or req.mime_type
+        source = base64.b64decode(raw, validate=True)
+        remote = await edit_pollinations_image(req.prompt, source_bytes=source, source_mime=req.mime_type)
+        return {"ok": True, "image_url": remote.url, "mime": remote.mime_type,
+                "provider": remote.provider, "revised_prompt": remote.revised_prompt}
+    except (ValueError, base64.binascii.Error):
+        return {"ok": False, "error": "L’immagine di origine non è codificata correttamente.", "status_code": 400}
+    except ImageProviderError as exc:
+        return {"ok": False, "error": str(exc), "status_code": exc.status_code,
+                "retry_after": exc.retry_after}
 
 
 # ─── /analyze ───────────────────────────────────────────────────────────────��─

tests/test_image_provider.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pytest
+
+from api.image_provider import ImageProviderError, _read_remote_image, is_pollinations_remote_url
+
+
+def test_accepts_only_https_pollinations_urls() -> None:
+    assert is_pollinations_remote_url("https://image.pollinations.ai/prompt/cat?seed=1")
+    assert is_pollinations_remote_url("https://gen.pollinations.ai/image/cat")
+    assert not is_pollinations_remote_url("http://image.pollinations.ai/prompt/cat")
+    assert not is_pollinations_remote_url("https://example.com/image.jpg")
+    assert not is_pollinations_remote_url("data:image/jpeg;base64,AA==")
+    assert not is_pollinations_remote_url("https://image.pollinations.ai.evil.example/image")
+
+
+def test_parses_safe_remote_result() -> None:
+    image = _read_remote_image({
+        "data": [{
+            "url": "https://image.pollinations.ai/prompt/a-safe-cat?seed=7",
+            "media_type": "image/png",
+            "revised_prompt": "a safe cat",
+        }]
+    })
+    assert image.url.startswith("https://image.pollinations.ai/")
+    assert image.mime_type == "image/png"
+    assert image.revised_prompt == "a safe cat"
+
+
+def test_rejects_missing_or_untrusted_remote_result() -> None:
+    with pytest.raises(ImageProviderError):
+        _read_remote_image({"data": []})
+    with pytest.raises(ImageProviderError):
+        _read_remote_image({"data": [{"url": "https://example.com/image.jpg"}]})