@danhachuel/thunderbolt 0.5.60 → 0.5.61

package/app/main.py

@@ -7281,6 +7281,9 @@ def _persist_media_cards(settings: dict[str, Any], cards: list[dict[str, Any]],
 def _fetch_media_models(card: dict[str, Any]) -> list[str]:
     """Consultar modelos do provider, incluindo o catálogo nativo Gemini."""
     provider = str(card.get("provider") or "").strip().lower()
+    if provider == "huggingface":
+        from integrations.openai_model_discovery import fetch_huggingface_text_to_image_models
+        return fetch_huggingface_text_to_image_models(str(card.get("api_key") or ""))
     if provider == "replicate":
         from integrations.openai_model_discovery import fetch_replicate_models
         return fetch_replicate_models(str(card.get("api_key") or ""), str(card.get("base_url") or ""))

package/hermes_ui/api_key_tests.py

@@ -169,6 +169,14 @@ def test_media_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
     api_style = str(source.get("api_style") or "").strip().lower()
     if provider == "nano_banana":
         return test_nano_banana_credentials(api_key, model)
+    if provider == "huggingface":
+        if not api_key:
+            return _missing("Introduza o token Hugging Face antes de testar.")
+        return _get(
+            "https://huggingface.co/api/models",
+            headers={"Authorization": f"Bearer {api_key}"},
+            params={"pipeline_tag": "text-to-image", "limit": 1},
+        )
     if not base_url:
         return _result("missing", "Complete a Base URL antes de testar.")
     if provider not in {"inferenceport", "ollama", "lmstudio"} and not api_key:

package/hermes_ui/media_generation.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import base64
 import binascii
+import io
 import json
 import mimetypes
 import os
@@ -453,6 +454,35 @@ def generate_image_for_card(
     ensure_storage()
     destination = STORAGE / "thumbnails" / f"media-{provider}-{abs(hash((topic, prompt, variant_index))) & 0xffffffffffffffff:x}.jpg"
 
+    if provider == "huggingface":
+        model = _model(card)
+        token = _api_key(card)
+        if not model:
+            raise MediaGenerationError("Hugging Face requer a selecção de um modelo text-to-image.")
+        try:
+            image_prompt, _headline = _compose_thumbnail_prompt(
+                prompt,
+                topic=topic,
+                lettering_text=lettering_text,
+                lettering_prompt=lettering_prompt,
+            )
+            constrained_prompt = _append_generation_constraints(
+                image_prompt,
+                kind="image",
+                aspect_ratio="16:9",
+                size="1280x720 minimum",
+            )
+            from huggingface_hub import InferenceClient
+            image = InferenceClient(token=token or None, provider="hf-inference").text_to_image(
+                prompt=constrained_prompt,
+                model=model,
+            )
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            return _download_or_write(buffer.getvalue(), "", destination, card)
+        except Exception as exc:
+            raise MediaGenerationError(f"Hugging Face text-to-image falhou: {str(exc)[:240]}") from exc
+
     def request(current: dict[str, Any]) -> Any:
         return _image_request(current, prompt, topic=topic, lettering_text=lettering_text, lettering_prompt=lettering_prompt)
 

package/hermes_ui/media_providers.py

@@ -113,11 +113,11 @@ MEDIA_PROVIDER_CATALOG: tuple[MediaProviderDefinition, ...] = (
     MediaProviderDefinition(
         "huggingface",
         "Hugging Face Inference API",
-        default_base_url="https://router.huggingface.co/v1",
+        default_base_url="https://huggingface.co",
         supports_image=True,
-        supports_text=True,
+        supports_text=False,
         api_style="huggingface",
-        description="Inference Providers; a capacidade depende do modelo seleccionado.",
+        description="Hugging Face Inference API para imagens via InferenceClient com provider hf-inference; não usa endpoint OpenAI-compatible.",
     ),
     MediaProviderDefinition(
         "cloudflare_workers_ai",
@@ -230,7 +230,7 @@ def normalize_media_card(card: Any, index: int = 0) -> dict[str, Any]:
         "provider": provider,
         "api_key": str(source.get("api_key") or source.get("key") or "").strip(),
         "model": str(source.get("model") or source.get("model_name") or "").strip(),
-        "base_url": str(source.get("base_url") or "").strip() or definition.default_base_url,
+        "base_url": definition.default_base_url if provider == "huggingface" else (str(source.get("base_url") or "").strip() or definition.default_base_url),
         "enabled": bool(source.get("enabled", True)),
         "priority": max(0, int(source.get("priority", index)) if str(source.get("priority", index)).strip().lstrip("-").isdigit() else index),
         "supports_image": bool(source.get("supports_image", definition.supports_image)),

package/integrations/openai_model_discovery.py

@@ -210,6 +210,40 @@ def fetch_openai_compatible_models(
     return normalize_model_ids(payload)
 
 
+def fetch_huggingface_text_to_image_models(
+    api_key: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT_SECONDS,
+    limit: int = 2000,
+) -> list[str]:
+    """List only public Hugging Face models tagged with ``text-to-image``."""
+    token = str(api_key or "").strip()
+    headers = {"Accept": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try:
+        response = requests.get(
+            "https://huggingface.co/api/models",
+            params={"pipeline_tag": "text-to-image", "limit": min(max(int(limit), 1), MAX_MODEL_IDS), "sort": "downloads", "direction": -1},
+            headers=headers,
+            timeout=timeout,
+        )
+    except requests.RequestException as exc:
+        raise ModelDiscoveryError(f"Não foi possível consultar o catálogo text-to-image da Hugging Face: {exc}") from exc
+    if response.status_code >= 400:
+        raise ModelDiscoveryError(f"O catálogo text-to-image da Hugging Face devolveu HTTP {response.status_code}.")
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise ModelDiscoveryError("O catálogo Hugging Face devolveu uma resposta que não é JSON.") from exc
+    if not isinstance(payload, list):
+        raise ModelDiscoveryError("O catálogo Hugging Face não devolveu uma lista de modelos.")
+    models = sorted({str(item.get("id") or "").strip() for item in payload if isinstance(item, dict) and str(item.get("id") or "").strip()}, key=str.casefold)
+    if not models:
+        raise ModelDiscoveryError("A Hugging Face não devolveu modelos com pipeline text-to-image.")
+    return models[:MAX_MODEL_IDS]
+
+
 def fetch_replicate_models(
     api_key: str,
     base_url: str,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.5.60",
+  "version": "0.5.61",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",

package/requirements.txt

@@ -1,6 +1,7 @@
 streamlit>=1.37,<2
 requests[socks]>=2.31,<3
 Pillow>=10,<12
+huggingface_hub>=0.30,<1
 pandas>=2.0,<3
 openpyxl>=3.1,<4
 xlrd>=2.0,<3