@danhachuel/thunderbolt 0.3.41 → 0.3.43

package/hermes_ui/media_providers.py

@@ -0,0 +1,282 @@
+"""Configuration schema for independent image and video provider pools."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+MEDIA_CARDS_KEY = "media_provider_cards"
+MEDIA_IMAGE_ACTIVE_CARD_KEY = "media_image_active_card_id"
+MEDIA_VIDEO_ACTIVE_CARD_KEY = "media_video_active_card_id"
+MEDIA_IMAGE_ACTIVE_PROVIDER_KEY = "media_image_provider"
+MEDIA_VIDEO_ACTIVE_PROVIDER_KEY = "media_video_provider"
+
+
+@dataclass(frozen=True, slots=True)
+class MediaProviderDefinition:
+    code: str
+    label: str
+    default_base_url: str = ""
+    requires_api_key: bool = True
+    supports_image: bool = False
+    supports_video: bool = False
+    supports_text: bool = False
+    local: bool = False
+    api_style: str = "custom"
+    extra_fields: tuple[str, ...] = ()
+    description: str = ""
+
+
+MEDIA_PROVIDER_CATALOG: tuple[MediaProviderDefinition, ...] = (
+    MediaProviderDefinition(
+        "nano_banana",
+        "Nano Banana",
+        default_base_url="https://generativelanguage.googleapis.com/v1beta",
+        supports_image=True,
+        api_style="gemini_interactions",
+        extra_fields=("aspect_ratio", "image_size"),
+        description="Geração de imagem nativa Gemini para thumbnails e artes.",
+    ),
+    MediaProviderDefinition(
+        "pollinations",
+        "Pollinations.ai",
+        default_base_url="https://gen.pollinations.ai/v1",
+        supports_image=True,
+        supports_video=True,
+        supports_text=True,
+        api_style="openai_compatible",
+        description="Gateway multimodal com endpoints compatíveis e catálogo próprio.",
+    ),
+    MediaProviderDefinition(
+        "agnes",
+        "Agnes AI",
+        default_base_url="https://apihub.agnes-ai.com/v1",
+        supports_image=True,
+        supports_video=True,
+        supports_text=True,
+        api_style="agnes",
+        description="Gateway multimodal Agnes para texto, imagem e vídeo.",
+    ),
+    MediaProviderDefinition(
+        "huggingface",
+        "Hugging Face Inference API",
+        default_base_url="https://router.huggingface.co/v1",
+        supports_image=True,
+        supports_text=True,
+        api_style="huggingface",
+        description="Inference Providers; a capacidade depende do modelo seleccionado.",
+    ),
+    MediaProviderDefinition(
+        "cloudflare_workers_ai",
+        "Cloudflare Workers AI",
+        default_base_url="https://api.cloudflare.com/client/v4",
+        supports_image=True,
+        api_style="cloudflare",
+        extra_fields=("account_id",),
+        description="Workers AI com Account ID e API token; a rota de modelo é derivada.",
+    ),
+    MediaProviderDefinition(
+        "inferenceport",
+        "InferencePort Proxy",
+        default_base_url="http://localhost:8080/v1",
+        requires_api_key=False,
+        supports_image=True,
+        supports_video=True,
+        supports_text=True,
+        local=True,
+        api_style="openai_compatible",
+        description="Proxy local OpenAI-compatible; não exige API key por defeito.",
+    ),
+    MediaProviderDefinition(
+        "alibaba_cloud",
+        "阿里云 (Alibaba Cloud Model Studio)",
+        default_base_url="https://dashscope-intl.aliyuncs.com/api/v1",
+        supports_image=True,
+        supports_video=True,
+        supports_text=True,
+        api_style="dashscope",
+        extra_fields=("region",),
+        description="DashScope/Model Studio; tarefas de imagem e vídeo podem ser assíncronas.",
+    ),
+    MediaProviderDefinition(
+        "kie_ai",
+        "KIE AI",
+        default_base_url="https://api.kie.ai/api/v1",
+        supports_image=True,
+        supports_video=True,
+        supports_text=True,
+        api_style="kie",
+        description="Gateway multimodal com tarefas e consulta de resultados.",
+    ),
+    MediaProviderDefinition(
+        "fal_ai",
+        "FAL AI",
+        default_base_url="https://queue.fal.run",
+        supports_image=True,
+        supports_video=True,
+        api_style="fal_queue",
+        description="Model APIs da FAL com queue, status e resultado.",
+    ),
+)
+
+_MEDIA_BY_CODE = {item.code: item for item in MEDIA_PROVIDER_CATALOG}
+
+
+def media_provider_catalog() -> list[dict[str, Any]]:
+    return [
+        {
+            "code": item.code,
+            "label": item.label,
+            "default_base_url": item.default_base_url,
+            "requires_api_key": item.requires_api_key,
+            "supports_image": item.supports_image,
+            "supports_video": item.supports_video,
+            "supports_text": item.supports_text,
+            "local": item.local,
+            "api_style": item.api_style,
+            "extra_fields": item.extra_fields,
+            "description": item.description,
+        }
+        for item in MEDIA_PROVIDER_CATALOG
+    ]
+
+
+def media_provider_definition(provider: Any) -> MediaProviderDefinition:
+    code = str(provider or "").strip().lower()
+    return _MEDIA_BY_CODE.get(code, _MEDIA_BY_CODE["inferenceport"])
+
+
+def normalize_media_card(card: Any, index: int = 0) -> dict[str, Any]:
+    source = dict(card) if isinstance(card, Mapping) else {}
+    provider = str(source.get("provider") or "nano_banana").strip().lower()
+    definition = media_provider_definition(provider)
+    if provider not in _MEDIA_BY_CODE:
+        provider = definition.code
+    card_id = str(source.get("id") or f"media-{provider}-{index + 1}").strip()
+    result: dict[str, Any] = {
+        "id": card_id,
+        "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,
+        "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)),
+        "supports_video": bool(source.get("supports_video", definition.supports_video)),
+        "supports_text": bool(source.get("supports_text", definition.supports_text)),
+        "api_style": definition.api_style,
+        "local": definition.local,
+    }
+    for field in definition.extra_fields:
+        result[field] = str(source.get(field) or "").strip()
+    test_result = source.get("test_result")
+    if isinstance(test_result, Mapping) and str(test_result.get("status") or "") in {"success", "error"}:
+        result["test_result"] = {
+            "status": str(test_result.get("status")),
+            "message": str(test_result.get("message") or "")[:240],
+            "tested_at": str(test_result.get("tested_at") or "")[:64],
+        }
+    return result
+
+
+def new_media_card(provider: Any, *, card_id: str | None = None) -> dict[str, Any]:
+    code = str(provider or "").strip().lower()
+    if code not in _MEDIA_BY_CODE:
+        raise ValueError("Provider de imagem/vídeo inválido.")
+    definition = _MEDIA_BY_CODE[code]
+    return normalize_media_card(
+        {
+            "id": card_id or f"media-{code}-1",
+            "provider": code,
+            "model": "gemini-3.1-flash-image" if code == "nano_banana" else "",
+            "base_url": definition.default_base_url,
+            "enabled": True,
+        }
+    )
+
+
+def ensure_media_provider_cards(settings: Mapping[str, Any]) -> tuple[dict[str, Any], bool]:
+    result = dict(settings)
+    raw_cards = result.get(MEDIA_CARDS_KEY)
+    changed = False
+    if isinstance(raw_cards, list) and raw_cards:
+        cards = [normalize_media_card(item, index) for index, item in enumerate(raw_cards)]
+        changed = cards != raw_cards
+    else:
+        cards: list[dict[str, Any]] = []
+        legacy_key = str(result.get("gemini_image_api_key") or "").strip()
+        legacy_model = str(result.get("gemini_image_model") or "gemini-3.1-flash-image").strip()
+        cards.append(
+            normalize_media_card(
+                {
+                    "id": "media-nano-banana-default",
+                    "provider": "nano_banana",
+                    "api_key": legacy_key,
+                    "model": legacy_model,
+                    "base_url": "https://generativelanguage.googleapis.com/v1beta",
+                    "aspect_ratio": str(result.get("gemini_image_aspect_ratio") or "16:9"),
+                    "image_size": str(result.get("gemini_image_size") or "1K"),
+                    "enabled": True,
+                },
+                0,
+            )
+        )
+        changed = True
+    result[MEDIA_CARDS_KEY] = cards
+
+    for pool, key, capability in (
+        ("image", MEDIA_IMAGE_ACTIVE_CARD_KEY, "supports_image"),
+        ("video", MEDIA_VIDEO_ACTIVE_CARD_KEY, "supports_video"),
+    ):
+        active_id = str(result.get(key) or "").strip()
+        valid = [card for card in cards if card.get(capability) and card.get("enabled", True)]
+        if active_id not in {str(card.get("id")) for card in cards} or not any(str(card.get("id")) == active_id and card.get(capability) and card.get("enabled", True) for card in cards):
+            active_id = str(valid[0].get("id")) if valid else ""
+            if result.get(key) != active_id:
+                result[key] = active_id
+                changed = True
+        legacy_provider_key = MEDIA_IMAGE_ACTIVE_PROVIDER_KEY if pool == "image" else MEDIA_VIDEO_ACTIVE_PROVIDER_KEY
+        active_card = next((card for card in cards if str(card.get("id")) == active_id), None)
+        active_provider = str(active_card.get("provider") or "") if active_card else ""
+        if result.get(legacy_provider_key) != active_provider:
+            result[legacy_provider_key] = active_provider
+            changed = True
+    return result, changed
+
+
+def apply_media_provider_cards_to_settings(settings: Mapping[str, Any], cards: list[Mapping[str, Any]], image_active_id: str = "", video_active_id: str = "") -> dict[str, Any]:
+    result = dict(settings)
+    normalized = [normalize_media_card(item, index) for index, item in enumerate(cards)]
+    if not normalized:
+        normalized = [new_media_card("nano_banana", card_id="media-nano-banana-default")]
+    result[MEDIA_CARDS_KEY] = normalized
+    for key, wanted, capability in (
+        (MEDIA_IMAGE_ACTIVE_CARD_KEY, image_active_id, "supports_image"),
+        (MEDIA_VIDEO_ACTIVE_CARD_KEY, video_active_id, "supports_video"),
+    ):
+        selected = next((card for card in normalized if str(card.get("id")) == str(wanted) and card.get(capability) and card.get("enabled", True)), None)
+        if selected is None:
+            selected = next((card for card in normalized if card.get(capability) and card.get("enabled", True)), None)
+        result[key] = str(selected.get("id")) if selected else ""
+    image_card = next((card for card in normalized if str(card.get("id")) == result[MEDIA_IMAGE_ACTIVE_CARD_KEY]), None)
+    video_card = next((card for card in normalized if str(card.get("id")) == result[MEDIA_VIDEO_ACTIVE_CARD_KEY]), None)
+    result[MEDIA_IMAGE_ACTIVE_PROVIDER_KEY] = str(image_card.get("provider") or "") if image_card else ""
+    result[MEDIA_VIDEO_ACTIVE_PROVIDER_KEY] = str(video_card.get("provider") or "") if video_card else ""
+    nano_card = next((card for card in normalized if card.get("provider") == "nano_banana"), None)
+    if nano_card:
+        result["gemini_image_api_key"] = str(nano_card.get("api_key") or "")
+        result["gemini_image_model"] = str(nano_card.get("model") or "gemini-3.1-flash-image")
+        result["gemini_image_aspect_ratio"] = str(nano_card.get("aspect_ratio") or result.get("gemini_image_aspect_ratio") or "16:9")
+        result["gemini_image_size"] = str(nano_card.get("image_size") or result.get("gemini_image_size") or "1K")
+    return result
+
+
+def media_cards_for_pool(settings: Mapping[str, Any], pool: str) -> list[dict[str, Any]]:
+    migrated, _ = ensure_media_provider_cards(settings)
+    capability = "supports_image" if pool == "image" else "supports_video" if pool == "video" else "supports_text"
+    active_key = MEDIA_IMAGE_ACTIVE_CARD_KEY if pool == "image" else MEDIA_VIDEO_ACTIVE_CARD_KEY if pool == "video" else ""
+    active_id = str(migrated.get(active_key) or "")
+    cards = [dict(item) for item in migrated.get(MEDIA_CARDS_KEY, []) if item.get("enabled", True) and item.get(capability)]
+    cards.sort(key=lambda card: (0 if str(card.get("id")) == active_id else 1, int(card.get("priority", 0))))
+    return cards

package/hermes_ui/pipeline_worker.py

@@ -17,6 +17,8 @@ from hermes_ui.script_documents import save_script_document
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.storage import STORAGE, ensure_storage, read_json, write_json
 from hermes_ui.llm_providers import active_llm_card, provider_definition
+from hermes_ui.media_generation import MediaGenerationError, generate_image_from_pool, generate_video_from_pool
+from hermes_ui.media_providers import media_cards_for_pool
 from hermes_ui.thumbnail_generation import generate_thumbnail_image
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
@@ -43,6 +45,36 @@ def _settings() -> dict[str, Any]:
     return value if isinstance(value, dict) else {}
 
 
+def _generate_pipeline_thumbnail(
+    settings: dict[str, Any],
+    prompt: str,
+    *,
+    topic: str,
+    variant_index: int = 0,
+    lettering_text: str = "",
+    lettering_prompt: str = "",
+) -> Path:
+    """Use the image pool while keeping the legacy single-Nano call seam."""
+    cards = media_cards_for_pool(settings, "image")
+    if len(cards) == 1 and str(cards[0].get("provider") or "") == "nano_banana":
+        return generate_thumbnail_image(
+            settings,
+            prompt,
+            topic=topic,
+            variant_index=variant_index,
+            lettering_text=lettering_text,
+            lettering_prompt=lettering_prompt,
+        )
+    return generate_image_from_pool(
+        settings,
+        prompt,
+        topic=topic,
+        variant_index=variant_index,
+        lettering_text=lettering_text,
+        lettering_prompt=lettering_prompt,
+    )
+
+
 def _lock_path() -> Path:
     ensure_storage()
     return STORAGE / "state" / PIPELINE_LOCK_FILENAME
@@ -470,8 +502,26 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     _update(task_id, artifacts=artifacts, progress=30)
 
     _update(task_id, stage="title", state="doing", progress=35)
-    creative = generate_creative_package(settings, channel, topic, blueprint, language=str(task.get("language") or channel.get("language") or "Português"))
-    title = str(creative.get("title") or topic).strip()
+    provided_title = str(task.get("title") or "").strip()
+    existing_variant = task.get("thumbnail_variant") if isinstance(task.get("thumbnail_variant"), dict) else {}
+    existing_variant = dict(existing_variant)
+    if not str(existing_variant.get("image_prompt") or "").strip() and str(task.get("thumbnail_prompt") or "").strip():
+        existing_variant["image_prompt"] = str(task.get("thumbnail_prompt") or "").strip()
+    if not str(existing_variant.get("overlay_text") or "").strip() and str(task.get("thumbnail_text") or "").strip():
+        existing_variant["overlay_text"] = str(task.get("thumbnail_text") or "").strip()
+    prepared_thumbnail = bool(str(existing_variant.get("image_prompt") or "").strip())
+    if provided_title and prepared_thumbnail:
+        # The creation UI already generated the title/thumbnail brief. Do not call
+        # the complete creative-package generator a second time for this task.
+        creative = {
+            "title": provided_title,
+            "keywords": [],
+            "thumbnail_variant": existing_variant,
+            "title_candidates": task.get("title_candidates") if isinstance(task.get("title_candidates"), list) else [],
+        }
+    else:
+        creative = generate_creative_package(settings, channel, topic, blueprint, language=str(task.get("language") or channel.get("language") or "Português"))
+    title = str(creative.get("title") or provided_title or topic).strip()
     provided_keywords = generation_settings.get("video_keywords")
     if isinstance(provided_keywords, str):
         provided_keywords = re.split(r"[,\n;|]+", provided_keywords)
@@ -482,6 +532,8 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
 
     _update(task_id, stage="keywords", state="doing", progress=48)
     variant = creative.get("thumbnail_variant") if isinstance(creative.get("thumbnail_variant"), dict) else {}
+    if not variant and prepared_thumbnail:
+        variant = existing_variant
     prompt_payload = {
         "topic": topic,
         "title": title,
@@ -501,7 +553,7 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     artifacts = {**artifacts, "thumbnail_prompt_json": prompt_artifact}
     _update(task_id, stage="thumbnail_prompt", state="doing", progress=52, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
     _update(task_id, stage="thumbnail", state="doing", progress=56, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
-    thumbnail_path = generate_thumbnail_image(
+    thumbnail_path = _generate_pipeline_thumbnail(
         settings,
         str(variant.get("image_prompt") or ""),
         topic=topic,
@@ -513,7 +565,15 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     _update(task_id, artifacts=artifacts, thumbnail_status="generated", progress=62)
 
     _update(task_id, stage="video", state="doing", progress=68)
-    video_path = _run_video_helper({**task, "topic": topic})
+    video_cards = media_cards_for_pool(settings, "video")
+    if bool(settings.get("media_video_pool_enabled")) and video_cards:
+        try:
+            video_prompt = f"Título: {title}\n\nRoteiro:\n{str(script.get('content') or '')[:12000]}"
+            video_path = generate_video_from_pool(settings, video_prompt)
+        except MediaGenerationError as exc:
+            raise PipelineError(f"Pool de vídeo externo: {exc}") from exc
+    else:
+        video_path = _run_video_helper({**task, "topic": topic})
     artifacts["video"] = str(video_path)
     _update(task_id, artifacts=artifacts, progress=80)