@danhachuel/thunderbolt 0.4.10 → 0.4.12

package/README.md

@@ -44,9 +44,12 @@ A migração é baseada no workflow público [AI Agents A-Z — episódio 35](ht
 
 ## Pipeline de vídeo — fontes e ordem de execução
 
-Em **Pipeline Vídeos > Criação de Vídeos** e **Automação Youtube**, a opção **Pexels/Pixabay** usa a rota stock do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo): as keywords do roteiro são encaminhadas para a pesquisa da fonte seleccionada, os clips são descarregados e reutilizados localmente, e o motor faz a composição com MoviePy/FFmpeg, respeitando proporção, duração máxima, concatenação, transições, correspondência visual ao roteiro, narração, legendas e música de fundo. As API keys de Pexels e Pixabay são exportadas para o `config.toml` do motor e a fonte efectiva é encaminhada por tarefa, sem depender apenas da fonte global guardada nas configurações.
+Em **Pipeline Vídeos > Criação de Vídeos** e **Automação Youtube**, a opção **Pexels/Pixabay** usa a rota stock do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo): as keywords do roteiro são encaminhadas para a pesquisa da fonte seleccionada, os clips são descarregados e reutilizados localmente, e o motor faz a composição com MoviePy/FFmpeg, respeitando proporção, duração máxima, concatenação, transições, correspondência visual ao roteiro, narração, legendas e música de fundo. As API keys de Pexels e Pixabay são exportadas para o `config.toml` do motor e a fonte efectiva é encaminhada por tarefa, sem depender apenas da fonte global guardada nas configurações. Em **Configurações > Configuração API > API Keys > Imagem e Video Montagem/MoviePy**, cada cartão possui o campo **Prioridade**: o menor número aparece primeiro e a ordenação fica guardada no storage local.
 
-A ordem persistida da criação é **Tema → Script → Título → Keywords opcional → Vídeo → Prompt Thumbnail em JSON → Thumbnail → Upload**. O vídeo é materializado antes do prompt e da imagem da thumbnail; uma falha posterior de thumbnail não invalida um MP4 já pronto. **Full IA** é uma rota separada e usa o pool de vídeo configurável com **FAL AI, KIE AI, Agnes AI, Nano Banana, Replicate AI, Pollinations.ai, Hugging Face Inference API, InferencePort Proxy e HeyGen**, respeitando apenas cartões activos que declarem capacidade de vídeo. **Apenas Música** não chama a pipeline de vídeo nem tenta gerar thumbnail: reutiliza o áudio local/Suno já descarregado e deixa-o pronto para a integração de upload musical.
+Quando existem cartões activos de **Pexels** e **Pixabay**, a Pipeline tenta primeiro a fonte seleccionada na tarefa e, se a falha for específica do provider stock, tenta os restantes providers stock configurados por ordem de prioridade. Falhas de LLM, Azure, áudio local ou configuração estrutural não são mascaradas por um fallback de materiais.
+
+A ordem persistida da criação é **Tema → Script → Título → Keywords opcional → Vídeo → Prompt Thumbnail em JSON → Thumbnail → Upload**.
+O vídeo é materializado antes do prompt e da imagem da thumbnail; uma falha posterior de thumbnail não invalida um MP4 já pronto. **Full IA** é uma rota separada e usa o pool de vídeo configurável com **FAL AI, KIE AI, Agnes AI, Nano Banana, Replicate AI, Pollinations.ai, Hugging Face Inference API, InferencePort Proxy e HeyGen**, respeitando apenas cartões activos que declarem capacidade de vídeo. **Apenas Música** não chama a pipeline de vídeo nem tenta gerar thumbnail: reutiliza o áudio local/Suno já descarregado e deixa-o pronto para a integração de upload musical.
 
 Quando uma etapa falha, a tarefa, a notificação e a página **Configurações > Logs** guardam e mostram sempre a coluna **API/Provider**, o serviço, a rota e, quando aplicável, os campos de configuração em falta. No caso do MoneyPrinterTurbo, os marcadores `LLM_PROVIDER`, `MISSING` e `INVALID` são convertidos em attribution legível; por exemplo, um erro pode indicar simultaneamente **OpenAI / NVIDIA NIM API** e **Pexels API**, em vez de apresentar apenas a mensagem genérica de credenciais adicionais. Os timeouts `azure_tts_v1`/`edge_tts` são identificados como **Azure Speech / edge_tts API**. Quando há Azure Speech key e região, o worker encaminha a voz para o SDK Azure Speech V2. Para evitar o limite de 10 minutos da síntese em tempo real documentado pela [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-services-quotas-and-limits), o helper divide o roteiro em segmentos seguros, sintetiza-os sequencialmente com retry e concatena o MP3 antes de o entregar ao MoneyPrinterTurbo como áudio customizado. O erro `1007`/`600000ms` é atribuído explicitamente à **Azure Speech SDK V2 API**. Sem credenciais Azure, o fallback edge_tts usa um timeout interno de 90 segundos. O worker invoca o helper com `--` antes das flags MoneyPrinterTurbo, porque `mpt_agent.py` reserva esses argumentos para a CLI filha. Registos históricos sem metadata são identificados explicitamente como anteriores à attribution estruturada.
 

package/app/main.py

@@ -5617,7 +5617,7 @@ def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str,
             _render_credential_status("" if is_local else card.get("api_key"), local=is_local, required=not is_local)
         card_form = nullcontext() if embedded else st.form(f"material_source_card_form_{card_id}")
         with card_form:
-            content_cols = st.columns(2)
+            content_cols = st.columns([1.4, 1.25, 0.85])
             with content_cols[0]:
                 if is_local:
                     st.caption("Esta fonte não usa API key.")
@@ -5631,6 +5631,16 @@ def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str,
                     value=active_card_id == card_id,
                     key=f"material_card_{card_id}_selected",
                 )
+            with content_cols[2]:
+                priority = st.number_input(
+                    "Prioridade",
+                    min_value=1,
+                    max_value=999,
+                    value=max(1, int(card.get("priority", index + 1))),
+                    step=1,
+                    help="1 é o primeiro provider da fila. Em caso de falha elegível, os providers seguintes são considerados por ordem crescente.",
+                    key=f"material_card_{card_id}_priority",
+                )
             if not is_local:
                 _render_api_test_control(
                     settings,
@@ -5640,7 +5650,12 @@ def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str,
                 )
             save_card = st.form_submit_button("Salvar", type="primary", use_container_width=True, key=f"material_card_{card_id}_save")
         if save_card:
-            cards[index] = {**card, "api_key": str(api_key or "").strip(), "enabled": bool(enabled)}
+            cards[index] = {
+                **card,
+                "api_key": str(api_key or "").strip(),
+                "enabled": bool(enabled),
+                "priority": max(1, int(priority)),
+            }
             selected_id = card_id if selected and enabled else active_card_id
             _persist_material_source_cards(settings, cards, selected_id)
             st.success(f"Fonte {definition['label']} guardada.")
@@ -5668,7 +5683,12 @@ def render_material_source_api_keys(settings: dict[str, Any], *, embedded: bool
         )
         add_source_clicked = st.form_submit_button("Configurar Nova Fonte de Materiais", type="primary", use_container_width=True, key="add_material_source_card") if embedded else st.button("Configurar Nova Fonte de Materiais", type="primary", use_container_width=True, key="add_material_source_card")
         if add_source_clicked:
-            cards.append(new_material_card(provider_to_add, card_id=f"material-{provider_to_add}-{uuid.uuid4().hex[:8]}"))
+            new_card = new_material_card(provider_to_add, card_id=f"material-{provider_to_add}-{uuid.uuid4().hex[:8]}")
+            new_card["priority"] = max(
+                (int(item.get("priority", index + 1)) for index, item in enumerate(cards)),
+                default=0,
+            ) + 1
+            cards.append(new_card)
             _persist_material_source_cards(settings, cards, str(settings.get("material_active_card_id") or ""))
             st.rerun()
 

package/hermes_ui/material_sources.py

@@ -6,6 +6,7 @@ from uuid import uuid4
 
 MATERIAL_CARDS_KEY = "material_source_cards"
 MATERIAL_ACTIVE_CARD_KEY = "material_active_card_id"
+DEFAULT_MATERIAL_PRIORITY = 1
 
 MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
     {"code": "pexels", "label": "Pexels", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pexels_api_keys"},
@@ -43,15 +44,29 @@ def material_source_definition(source: Any) -> dict[str, str] | None:
     return _SOURCE_BY_CODE.get(str(source or "").strip().lower())
 
 
-def _new_card(provider: str, api_key: str = "", *, card_id: str | None = None) -> dict[str, Any]:
+def _new_card(
+    provider: str,
+    api_key: str = "",
+    *,
+    card_id: str | None = None,
+    priority: int = DEFAULT_MATERIAL_PRIORITY,
+) -> dict[str, Any]:
     return {
         "id": card_id or f"material-{provider}-{uuid4().hex[:8]}",
         "provider": provider,
         "api_key": str(api_key or "").strip(),
         "enabled": True,
+        "priority": max(1, int(priority)),
     }
 
 
+def _normalise_priority(value: Any, fallback: int = DEFAULT_MATERIAL_PRIORITY) -> int:
+    try:
+        return max(1, int(value))
+    except (TypeError, ValueError):
+        return max(1, int(fallback or DEFAULT_MATERIAL_PRIORITY))
+
+
 def normalize_material_card(card: Any, index: int = 0) -> dict[str, Any]:
     raw = card if isinstance(card, dict) else {}
     provider = str(raw.get("provider") or raw.get("source") or "pexels").strip().lower()
@@ -63,9 +78,25 @@ def normalize_material_card(card: Any, index: int = 0) -> dict[str, Any]:
         "provider": provider,
         "api_key": str(raw.get("api_key") or raw.get("key") or "").strip() if provider != "local" else "",
         "enabled": bool(raw.get("enabled", True)),
+        "priority": _normalise_priority(raw.get("priority", index + 1), index + 1),
     }
 
 
+def _ordered_cards(cards: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    indexed = [(index, normalize_material_card(card, index)) for index, card in enumerate(cards)]
+    indexed.sort(key=lambda pair: (pair[1].get("priority", pair[0] + 1), pair[0]))
+    return [card for _index, card in indexed]
+
+
+def material_source_cards(settings: dict[str, Any], *, enabled_only: bool = False) -> list[dict[str, Any]]:
+    """Return material providers in stable priority order for the MoviePy queue."""
+    migrated, _ = ensure_material_source_cards(settings)
+    cards = [dict(item) for item in migrated.get(MATERIAL_CARDS_KEY, [])]
+    if enabled_only:
+        cards = [card for card in cards if card.get("enabled", True)]
+    return cards
+
+
 def _cards_key_mapping(cards: list[dict[str, Any]]) -> dict[str, list[str]]:
     mapping = {item["code"]: [] for item in MATERIAL_SOURCE_CATALOG}
     for index, raw_card in enumerate(cards):
@@ -94,12 +125,23 @@ def ensure_material_source_cards(settings: dict[str, Any]) -> tuple[dict[str, An
         cards: list[dict[str, Any]] = []
         for item in MATERIAL_SOURCE_CATALOG:
             for key in material_api_keys(settings, item["code"], _ignore_cards=True):
-                cards.append(_new_card(item["code"], key, card_id=f"material-{item['code']}-{len(cards)}"))
+                cards.append(
+                    _new_card(
+                        item["code"],
+                        key,
+                        card_id=f"material-{item['code']}-{len(cards)}",
+                        priority=len(cards) + 1,
+                    )
+                )
         if not cards:
             selected = selected_material_source(settings)
             cards.append(_new_card(selected if selected in _SOURCE_BY_CODE else "pexels", card_id="material-default-0"))
         changed = True
 
+    ordered_cards = _ordered_cards(cards)
+    if ordered_cards != cards:
+        changed = True
+    cards = ordered_cards
     settings[MATERIAL_CARDS_KEY] = cards
     active_id = str(settings.get(MATERIAL_ACTIVE_CARD_KEY) or "").strip()
     valid_ids = {str(card["id"]) for card in cards}
@@ -137,6 +179,7 @@ def apply_material_source_cards_to_settings(
     normalized_cards = [normalize_material_card(item, index) for index, item in enumerate(cards)]
     if not normalized_cards:
         normalized_cards = [_new_card("pexels", card_id="material-default-0")]
+    normalized_cards = _ordered_cards(normalized_cards)
     settings[MATERIAL_CARDS_KEY] = normalized_cards
     selected_card = next((card for card in normalized_cards if str(card["id"]) == str(active_card_id)), None)
     if selected_card is None:

package/hermes_ui/pipeline_worker.py

@@ -22,7 +22,7 @@ from hermes_ui.storage import STORAGE, atomic_write, ensure_storage, read_json,
 from hermes_ui.llm_providers import active_llm_card, provider_definition
 from hermes_ui.media_generation import MediaGenerationError, _append_generation_constraints, generate_image_from_pool, generate_video_from_pool
 from hermes_ui.media_providers import FULL_IA_VIDEO_PROVIDER_CODES, media_cards_for_pool, media_provider_definition
-from hermes_ui.material_sources import material_api_keys, selected_material_source
+from hermes_ui.material_sources import material_api_keys, material_source_cards, selected_material_source
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
@@ -38,9 +38,16 @@ CASCADE_STAGE_ORDER = ("topic", "script", "title", "keywords", "video", "thumbna
 class PipelineError(RuntimeError):
     """Raised when a pipeline stage cannot complete with an actionable error."""
 
-    def __init__(self, message: str, *, failure_metadata: dict[str, Any] | None = None):
+    def __init__(
+        self,
+        message: str,
+        *,
+        failure_metadata: dict[str, Any] | None = None,
+        fallback_eligible: bool = False,
+    ):
         super().__init__(message)
         self.failure_metadata = dict(failure_metadata or {})
+        self.fallback_eligible = bool(fallback_eligible)
 
 
 class PipelineStopped(PipelineError):
@@ -620,6 +627,30 @@ def _normalise_video_route(task: dict[str, Any], settings: dict[str, Any]) -> st
     return raw if raw in {"pexels", "pixabay", "local"} else "pexels"
 
 
+def _material_video_routes(task: dict[str, Any], settings: dict[str, Any]) -> list[str]:
+    """Return stock providers to try, starting with the task's selected source."""
+    route = _normalise_video_route(task, settings)
+    if route not in {"pexels", "pixabay"}:
+        return [route]
+
+    ordered_providers: list[str] = []
+    for card in material_source_cards(settings, enabled_only=True):
+        provider = str(card.get("provider") or "").strip().casefold()
+        if provider not in {"pexels", "pixabay"} or provider in ordered_providers:
+            continue
+        if material_api_keys(settings, provider):
+            ordered_providers.append(provider)
+
+    # A selected source is an explicit preference for this task. The remaining
+    # configured sources follow their persisted priority and are true fallbacks.
+    if route in ordered_providers:
+        ordered_providers.remove(route)
+        ordered_providers.insert(0, route)
+    elif material_api_keys(settings, route):
+        ordered_providers.insert(0, route)
+    return ordered_providers or [route]
+
+
 def _video_timeout_seconds(task: dict[str, Any], settings: dict[str, Any] | None = None) -> int:
     """Reserve extra bounded time only for long stock-video downloads and assembly."""
     effective_settings = settings if isinstance(settings, dict) else _settings()
@@ -633,7 +664,9 @@ def _video_timeout_seconds(task: dict[str, Any], settings: dict[str, Any] | None
 def _task_stale_timeout_seconds(task: dict[str, Any]) -> int:
     """Keep stale-task recovery aligned with the actual execution budget."""
     if str(task.get("stage") or "").strip().casefold() == "video":
-        return _video_timeout_seconds(task) + 5 * 60
+        settings = _settings()
+        attempts = max(1, len(_material_video_routes(task, settings)))
+        return _video_timeout_seconds(task, settings) * attempts + 5 * 60
     return STALE_TASK_SECONDS
 
 
@@ -820,7 +853,12 @@ def _moneyprinter_cli_args(task: dict[str, Any], route: str, settings: dict[str,
     return args
 
 
-def _run_video_helper(task: dict[str, Any]) -> Path:
+def _run_video_helper_once(
+    task: dict[str, Any],
+    *,
+    route_override: str = "",
+    settings: dict[str, Any] | None = None,
+) -> Path:
     helper_dir = Path(__file__).resolve().parents[1] / "seed" / "skills"
     helper = helper_dir / "mpt_agent.py"
     if not helper.is_file():
@@ -828,16 +866,23 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     subject = str(task.get("topic") or "").strip()
     if not subject:
         raise PipelineError("A etapa Vídeo não recebeu um tema válido.")
-    settings = _settings()
+    settings = settings if isinstance(settings, dict) else _settings()
     configured_root = _configured_moneyprinter_root(settings)
     task_id = str(task.get("id") or "").strip()
     if not task_id:
         raise PipelineError("A tarefa de vídeo não tem um identificador válido.")
     env = os.environ.copy()
+    for key in (
+        "MPT_PEXELS_API_KEY",
+        "MPT_PEXELS_API_KEYS",
+        "MPT_PIXABAY_API_KEY",
+        "MPT_PIXABAY_API_KEYS",
+    ):
+        env.pop(key, None)
     card = active_llm_card(settings)
     provider = str(card.get("provider") or "openai").strip()
     definition = provider_definition(provider)
-    route = _normalise_video_route(task, settings)
+    route = str(route_override or _normalise_video_route(task, settings)).strip().casefold()
     source_keys = material_api_keys(settings, route) if route in {"pexels", "pixabay"} else []
     if route in {"pexels", "pixabay"} and not source_keys:
         source_label = "Pexels" if route == "pexels" else "Pixabay"
@@ -987,7 +1032,11 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 _stop_process(process)
                 message = f"A etapa Vídeo excedeu o limite de {timeout_seconds // 60} minutos e foi encerrada."
                 metadata = _failure_attribution(task, settings, "video", error=message)
-                raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+                raise PipelineError(
+                    _failure_message(message, metadata),
+                    failure_metadata=metadata,
+                    fallback_eligible=True,
+                )
             if time.monotonic() - last_activity_at >= VIDEO_IDLE_TIMEOUT_SECONDS:
                 _stop_process(process)
                 message = (
@@ -995,7 +1044,11 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                     f"{VIDEO_IDLE_TIMEOUT_SECONDS // 60} minutos e foi encerrada."
                 )
                 metadata = _failure_attribution(task, settings, "video", error=message)
-                raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+                raise PipelineError(
+                    _failure_message(message, metadata),
+                    failure_metadata=metadata,
+                    fallback_eligible=True,
+                )
     finally:
         reader.join(timeout=2)
         _persist_video_diagnostics(task, "\n".join(output_lines))
@@ -1010,12 +1063,20 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
         message = "A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo"
         if detail:
             message += f". Detalhe do helper: {detail}"
-        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+        raise PipelineError(
+            _failure_message(message, metadata),
+            failure_metadata=metadata,
+            fallback_eligible=True,
+        )
     if result_code != 0:
         detail = _terminal_helper_detail(output) or "erro sem detalhes devolvidos pelo helper"
         metadata = _failure_attribution(task, settings, "video", error=detail, output=output)
         message = f"MoneyPrinterTurbo falhou na etapa Vídeo: {detail}"
-        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+        raise PipelineError(
+            _failure_message(message, metadata),
+            failure_metadata=metadata,
+            fallback_eligible=True,
+        )
     match = re.search(r"(?m)^VIDEO_FILE=(.+)$", output)
     video_path = Path(match.group(1).strip()).expanduser() if match else None
     if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
@@ -1030,10 +1091,66 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
         message = "MoneyPrinterTurbo terminou sem devolver um MP4 válido."
         metadata = _failure_attribution(task, settings, "video", error=message, output=output)
-        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+        raise PipelineError(
+            _failure_message(message, metadata),
+            failure_metadata=metadata,
+            fallback_eligible=True,
+        )
     return video_path
 
 
+def _stock_fallback_is_eligible(route: str, error: PipelineError) -> bool:
+    """Allow fallback only when the failed attempt points to its stock source."""
+    if route not in {"pexels", "pixabay"} or not getattr(error, "fallback_eligible", False):
+        return False
+    metadata = dict(getattr(error, "failure_metadata", {}) or {})
+    providers = {
+        item.strip().casefold()
+        for item in str(metadata.get("failure_provider") or "").split(",")
+        if item.strip()
+    }
+    if providers and providers - {route}:
+        return False
+    fields = {
+        item.strip().casefold()
+        for item in str(metadata.get("failure_config_fields") or "").split(",")
+        if item.strip()
+    }
+    if fields and fields - {f"{route}_api_key", f"{route}_api_keys"}:
+        return False
+    return True
+
+
+def _run_video_helper(task: dict[str, Any]) -> Path:
+    """Run the stock helper with provider fallback in the configured priority order."""
+    settings = _settings()
+    routes = _material_video_routes(task, settings)
+    if len(routes) <= 1:
+        return _run_video_helper_once(task, route_override=routes[0] if routes else "", settings=settings)
+
+    for index, route in enumerate(routes):
+        attempt_task = dict(task)
+        generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+        attempt_task["material_source"] = route
+        attempt_task["generation_settings"] = {**generation_settings, "material_source": route}
+        try:
+            return _run_video_helper_once(attempt_task, route_override=route, settings=settings)
+        except PipelineStopped:
+            raise
+        except PipelineError as exc:
+            if not _stock_fallback_is_eligible(route, exc) or index == len(routes) - 1:
+                metadata = dict(getattr(exc, "failure_metadata", {}) or {})
+                metadata["failure_route"] = route
+                metadata["fallback_attempts"] = " → ".join(_provider_api_label(item) for item in routes[: index + 1])
+                message = (
+                    f"Falha no provider {_provider_api_label(route)} após tentar "
+                    f"{metadata['fallback_attempts']}. Último erro: {exc}"
+                )
+                raise PipelineError(message, failure_metadata=metadata) from exc
+
+    raise PipelineError("Nenhum provider de vídeo stock configurado.")
+
+
 def _read_persisted_script(task: dict[str, Any], channel: dict[str, Any], blueprint: dict[str, Any], topic: str) -> dict[str, Any] | None:
     """Load a previously saved script so retries do not regenerate it."""
     artifacts = task.get("artifacts") if isinstance(task.get("artifacts"), dict) else {}

package/package.json

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