@danhachuel/thunderbolt 0.3.61 → 0.3.63

package/hermes_ui/pipeline_worker.py

@@ -11,6 +11,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+from integrations.moneyprinter_config import sync_moneyprinter_config
 from integrations.upload_routing import upload_with_default_route
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_title_and_keywords, generate_thumbnail_prompt, generate_topic_for_channel
 from hermes_ui.script_documents import save_script_document
@@ -19,6 +20,7 @@ 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, _append_generation_constraints, generate_image_from_pool, generate_video_from_pool
 from hermes_ui.media_providers import media_cards_for_pool
+from hermes_ui.material_sources import material_api_keys, selected_material_source
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
@@ -31,6 +33,10 @@ WORKER_HEARTBEAT_TIMEOUT_SECONDS = 15
 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):
+        super().__init__(message)
+        self.failure_metadata = dict(failure_metadata or {})
+
 
 class PipelineStopped(PipelineError):
     """Raised when the user stops a task while the worker is processing it."""
@@ -185,7 +191,9 @@ def _recover_stale_tasks() -> list[str]:
             f"A tarefa ficou sem heartbeat durante mais de {STALE_TASK_SECONDS // 60} minutos. "
             "Foi marcada como falhada para evitar execução eterna; reveja o log do worker."
         )
-        update_task(task_id, {"state": "failed", "error": message, "failed_stage": task.get("stage") or "pipeline"})
+        failed_stage = str(task.get("stage") or "pipeline")
+        metadata = _failure_attribution(task, _settings(), failed_stage, error=message)
+        update_task(task_id, {"state": "failed", "error": _failure_message(message, metadata), "failed_stage": failed_stage, **metadata})
         recovered.append(task_id)
     return recovered
 
@@ -274,13 +282,160 @@ def _helper_output_value(output: str, key: str) -> str:
 
 
 def _redact_helper_output(text: str) -> str:
-    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY"):
+    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY", "MPT_PIXABAY_API_KEY"):
         secret = os.environ.get(key, "").strip()
         if secret:
             text = text.replace(secret, "[redacted]")
     return text
 
 
+def _helper_failure_markers(output: str) -> dict[str, Any]:
+    missing = [item.strip() for item in re.findall(r"(?m)^MISSING=(.+)$", output) if item.strip()]
+    invalid = [item.strip() for item in re.findall(r"(?m)^INVALID=(.+)$", output) if item.strip()]
+    return {
+        "helper_provider": _helper_output_value(output, "LLM_PROVIDER"),
+        "missing_fields": list(dict.fromkeys(missing)),
+        "invalid_fields": list(dict.fromkeys(invalid)),
+    }
+
+
+def _provider_api_label(provider: str) -> str:
+    code = str(provider or "").strip().casefold()
+    if code in {"pexels", "pixabay"}:
+        return f"{code.capitalize()} API"
+    if code in {"local", "local_storage"}:
+        return "Ficheiro local"
+    return f"{provider_definition(code).label} API"
+
+
+def _failure_attribution(
+    task: dict[str, Any],
+    settings: dict[str, Any],
+    stage: str,
+    *,
+    error: str = "",
+    output: str = "",
+) -> dict[str, Any]:
+    """Return safe, human-readable API attribution for every pipeline failure."""
+    route = _normalise_video_route(task, settings)
+    markers = _helper_failure_markers(output)
+    missing = list(markers["missing_fields"])
+    invalid = list(markers["invalid_fields"])
+    provider_code = str(markers["helper_provider"] or "").strip().casefold()
+    combined = f"{output} {error}".casefold()
+
+    if stage == "video" and missing:
+        api_labels: list[str] = []
+        provider_values: list[str] = []
+        for field in [*missing, *invalid]:
+            if field.endswith("_api_keys"):
+                source = field.removesuffix("_api_keys")
+                label = _provider_api_label(source)
+                provider_values.append(source)
+            elif field.endswith("_api_key"):
+                source = field.removesuffix("_api_key")
+                label = _provider_api_label(source)
+                provider_values.append(source)
+            else:
+                label = field
+            if label not in api_labels:
+                api_labels.append(label)
+        return {
+            "failure_api": " + ".join(api_labels) or _provider_api_label(route),
+            "failure_provider": ", ".join(dict.fromkeys(provider_values or ([provider_code] if provider_code else [route]))),
+            "failure_service": "MoneyPrinterTurbo",
+            "failure_route": route,
+            "failure_config_fields": ", ".join(dict.fromkeys([*missing, *invalid])),
+            "failure_stage": stage,
+        }
+
+    if stage == "video" and route in {"pexels", "pixabay"}:
+        return {
+            "failure_api": _provider_api_label(route),
+            "failure_provider": route,
+            "failure_service": "MoneyPrinterTurbo",
+            "failure_route": route,
+            "failure_config_fields": f"{route}_api_keys",
+            "failure_stage": stage,
+        }
+    if stage == "video" and route == "full_ia":
+        providers = [("fal_ai", "FAL AI"), ("kie_ai", "KIE AI"), ("agnes", "Agnes AI")]
+        found = [label for code, label in providers if code in combined or label.casefold() in combined]
+        labels = found or [label for _, label in providers]
+        codes = [code for code, label in providers if label in labels] or [code for code, _ in providers]
+        return {
+            "failure_api": " / ".join(f"{label} API" for label in labels),
+            "failure_provider": ", ".join(codes),
+            "failure_service": "Pool de vídeo Full IA",
+            "failure_route": route,
+            "failure_config_fields": "",
+            "failure_stage": stage,
+        }
+    if stage in {"topic", "script", "title", "keywords", "thumbnail_prompt"}:
+        card = active_llm_card(settings)
+        provider = str(card.get("provider") or provider_code or "openai").strip()
+        return {
+            "failure_api": _provider_api_label(provider),
+            "failure_provider": provider,
+            "failure_service": "LLM textual",
+            "failure_route": route,
+            "failure_config_fields": "",
+            "failure_stage": stage,
+        }
+    if stage == "thumbnail":
+        cards = media_cards_for_pool(settings, "image")
+        labels = []
+        codes = []
+        for card in cards:
+            code = str(card.get("provider") or "").strip().casefold()
+            if not code:
+                continue
+            label = _provider_api_label(code)
+            if code in combined or label.casefold() in combined or len(cards) == 1:
+                labels.append(label)
+                codes.append(code)
+        if not labels:
+            labels = [_provider_api_label(str(card.get("provider") or "imagem")) for card in cards] or ["Pool Imagem API"]
+            codes = [str(card.get("provider") or "").strip() for card in cards if card.get("provider")] or ["image_pool"]
+        return {
+            "failure_api": " / ".join(labels),
+            "failure_provider": ", ".join(codes),
+            "failure_service": "Pool de imagem",
+            "failure_route": route,
+            "failure_config_fields": "",
+            "failure_stage": stage,
+        }
+    if stage == "upload":
+        return {
+            "failure_api": "YouTube Upload API",
+            "failure_provider": "youtube_upload",
+            "failure_service": "Upload",
+            "failure_route": route,
+            "failure_config_fields": "",
+            "failure_stage": stage,
+        }
+    return {
+        "failure_api": "API não identificada (falha anterior)",
+        "failure_provider": provider_code or "unknown",
+        "failure_service": "Thunderbolt",
+        "failure_route": route,
+        "failure_config_fields": ", ".join(dict.fromkeys([*missing, *invalid])),
+        "failure_stage": stage or "pipeline",
+    }
+
+
+def _failure_message(message: str, metadata: dict[str, Any]) -> str:
+    api = str(metadata.get("failure_api") or "API não identificada").strip()
+    provider = str(metadata.get("failure_provider") or "").strip()
+    fields = str(metadata.get("failure_config_fields") or "").strip()
+    suffix = f" API/provider: {api}"
+    if provider and provider.casefold() not in api.casefold():
+        suffix += f" (provider: {provider})"
+    if fields:
+        suffix += f"; configuração: {fields}"
+    return f"{message.rstrip('.')} —{suffix}."
+
+
 def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, str]:
     """Persist only bounded helper diagnostics and return its declared file paths."""
     task_id = str(task.get("id") or "").strip()
@@ -289,11 +444,15 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
     log_file = _helper_output_value(output, "LOG_FILE")
     result_file = _helper_output_value(output, "RESULT_FILE")
     try:
+        markers = _helper_failure_markers(output)
         payload: dict[str, Any] = {
             "captured_at": _now(),
             "log_file": log_file,
             "result_file": result_file,
             "output_tail": _redact_helper_output(output[-6000:]),
+            "helper_provider": markers["helper_provider"],
+            "missing_fields": markers["missing_fields"],
+            "invalid_fields": markers["invalid_fields"],
         }
         artifact_path = _save_json_artifact(task_id, "video-diagnostics", payload)
         current = _task_by_id(task_id) or task
@@ -324,6 +483,156 @@ def _stop_process(process: subprocess.Popen[str]) -> None:
         process.wait()
 
 
+def _normalise_video_route(task: dict[str, Any], settings: dict[str, Any]) -> str:
+    """Resolve the per-task source without conflating stock, AI and music routes."""
+    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    if bool(task.get("music_mode")):
+        return "music"
+    explicit_source = str(
+        task.get("material_source")
+        or generation_settings.get("material_source")
+        or generation_settings.get("video_material_source")
+        or ""
+    ).strip().casefold()
+    if explicit_source in {"pexels", "pixabay", "local"}:
+        return explicit_source
+    raw = str(task.get("style_wide") or generation_settings.get("video_source") or "pexels").strip().casefold()
+    if raw in {"full_ia", "full ia", "full-ai", "ai", "ia"}:
+        return "full_ia"
+    if raw in {"music", "apenas música", "apenas musica", "only music"}:
+        return "music"
+    if raw in {"pixabay", "pixabay only"}:
+        return "pixabay"
+    if raw in {"pexels", "pexels/pixabay", "stock", "materials", "materiales"}:
+        configured = selected_material_source(settings)
+        return configured if configured in {"pexels", "pixabay"} else "pexels"
+    return raw if raw in {"pexels", "pixabay", "local"} else "pexels"
+
+
+def _mpt_aspect_ratio(value: Any, format_value: Any = "") -> str:
+    raw = str(value or format_value or "").strip().casefold()
+    if raw in {"landscape 16:9", "wide", "16:9", "landscape"}:
+        return "16:9"
+    if raw in {"square 1:1", "square", "1:1"}:
+        return "1:1"
+    return "9:16"
+
+
+def _mpt_concat_mode(value: Any) -> str:
+    raw = str(value or "").strip().casefold()
+    return "sequential" if raw in {"sequential", "sequential concatenation", "ordem sequencial"} else "random"
+
+
+def _mpt_transition_mode(value: Any) -> str:
+    raw = str(value or "").strip().casefold()
+    return {"fade": "fade-in", "dissolve": "fade-out", "fade-in": "fade-in", "fade-out": "fade-out"}.get(raw, "none")
+
+
+def _mpt_percent(value: Any, fallback: float = 1.0) -> str:
+    raw = str(value or "").strip().replace("%", "")
+    try:
+        return str(max(0.0, min(2.0, float(raw) / 100.0)))
+    except ValueError:
+        return str(fallback)
+
+
+def _valid_audio_artifact(value: Any) -> Path | None:
+    path = _valid_artifact_path(value)
+    if path is None or path.suffix.lower() not in {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}:
+        return None
+    return path
+
+
+def _mpt_rate(value: Any, fallback: float = 1.0) -> str:
+    raw = str(value or "").strip().casefold().replace("x", "")
+    try:
+        return str(max(0.1, float(raw)))
+    except ValueError:
+        return str(fallback)
+
+
+def _mpt_video_language(value: Any) -> str:
+    """Convert common Thunderbolt labels to the language codes accepted by MPT."""
+    raw = str(value or "").strip()
+    folded = raw.casefold()
+    aliases = {
+        "português": "pt-BR", "portugues": "pt-BR", "português (brasil)": "pt-BR",
+        "portuguese": "pt-BR", "inglês": "en-US", "ingles": "en-US", "english": "en-US",
+        "espanhol": "es-ES", "español": "es-ES", "francês": "fr-FR", "frances": "fr-FR",
+        "alemão": "de-DE", "alemao": "de-DE", "italiano": "it-IT", "japonês": "ja-JP",
+        "japones": "ja-JP", "mandarim": "zh-CN", "chinês": "zh-CN", "chines": "zh-CN",
+    }
+    if folded in aliases:
+        return aliases[folded]
+    return raw if re.fullmatch(r"[A-Za-z]{2,3}(?:-[A-Za-z]{2,4})?", raw) else ""
+
+
+def _moneyprinter_cli_args(task: dict[str, Any], route: str) -> list[str]:
+    """Build the explicit MPT CLI contract for the stock Pexels/Pixabay route."""
+    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    args: list[str] = ["--video-source", route]
+    script = str(task.get("video_script") or generation_settings.get("video_script") or "").strip()
+    if script:
+        args.extend(["--video-script", script])
+    keywords = task.get("video_keywords") or generation_settings.get("video_keywords") or task.get("keywords") or task.get("tags")
+    if isinstance(keywords, str):
+        keywords = [part.strip() for part in re.split(r"[,;|\n]+", keywords) if part.strip()]
+    if isinstance(keywords, list):
+        terms = [str(item).strip() for item in keywords if str(item).strip()]
+        if terms:
+            args.extend(["--video-terms", ",".join(terms[:15])])
+
+    language = _mpt_video_language(task.get("language"))
+    if language:
+        args.extend(["--video-language", language])
+    format_value = str(task.get("format") or generation_settings.get("video_format") or "").strip().casefold()
+    if format_value in {"wide", "landscape", "16:9"}:
+        aspect_ratio = "16:9"
+    elif format_value in {"shorts", "portrait", "9:16"}:
+        aspect_ratio = "9:16"
+    else:
+        aspect_ratio = _mpt_aspect_ratio(generation_settings.get("video_aspect_ratio"), task.get("format"))
+    args.extend(["--video-aspect", aspect_ratio])
+    args.extend(["--video-concat-mode", _mpt_concat_mode(generation_settings.get("video_concatenation_mode"))])
+    args.extend(["--video-transition-mode", _mpt_transition_mode(generation_settings.get("video_transition_mode"))])
+    clip_duration = generation_settings.get("maximum_clip_duration")
+    if str(clip_duration or "").strip().isdigit() and int(clip_duration) > 0:
+        args.extend(["--video-clip-duration", str(int(clip_duration))])
+    if bool(generation_settings.get("match_visuals_to_script_order")):
+        args.append("--match-materials-to-script")
+
+    voice_mode = str(generation_settings.get("voiceover_mode") or "").strip().casefold()
+    voice = str(task.get("voice") or generation_settings.get("voice") or "").strip()
+    if voice_mode == "none" or voice_mode == "upload":
+        args.extend(["--voice-name", "no-voice"])
+    elif voice:
+        args.extend(["--voice-name", voice])
+    volume = generation_settings.get("voiceover_volume")
+    speed = generation_settings.get("voiceover_speed")
+    if volume is not None:
+        args.extend(["--voice-volume", _mpt_percent(volume)])
+    if speed is not None:
+        args.extend(["--voice-rate", _mpt_rate(speed)])
+
+    subtitles = generation_settings.get("enable_subtitles")
+    if subtitles is not None:
+        args.append("--subtitle-enabled" if bool(subtitles) else "--no-subtitle-enabled")
+    subtitle_position = str(generation_settings.get("subtitle_position") or "").strip().casefold()
+    if subtitle_position in {"top", "center", "bottom", "custom"}:
+        args.extend(["--subtitle-position", subtitle_position])
+    font_name = str(generation_settings.get("subtitle_font") or "").strip()
+    if font_name:
+        args.extend(["--font-name", font_name])
+    bgm_source = str(generation_settings.get("background_music_source") or "").strip().casefold()
+    bgm_type = {"sem música": "none", "sem musica": "none", "random background music": "random", "ficheiro existente": "custom"}.get(bgm_source)
+    if bgm_type:
+        args.extend(["--bgm-type", bgm_type])
+    bgm_volume = generation_settings.get("background_music_volume")
+    if bgm_volume is not None:
+        args.extend(["--bgm-volume", _mpt_percent(bgm_volume)])
+    return args
+
+
 def _run_video_helper(task: dict[str, Any]) -> Path:
     helper_dir = Path(__file__).resolve().parents[1] / "seed" / "skills"
     helper = helper_dir / "mpt_agent.py"
@@ -341,12 +650,27 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     card = active_llm_card(settings)
     provider = str(card.get("provider") or "openai").strip()
     definition = provider_definition(provider)
+    route = _normalise_video_route(task, settings)
+    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"
+        message = f"Configure pelo menos uma API key de {source_label} em Configurações > Configuração API > Fontes de materiais."
+        metadata = _failure_attribution(task, settings, "video", error=message)
+        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+    if configured_root:
+        try:
+            sync_moneyprinter_config(settings, str(configured_root))
+        except OSError as exc:
+            raise PipelineError(f"Não foi possível sincronizar a configuração do MoneyPrinterTurbo: {exc}") from exc
     env_values = {
         "MPT_LLM_PROVIDER": provider,
         "MPT_LLM_API_KEY": str(card.get("api_key") or "").strip(),
         "MPT_LLM_BASE_URL": str(card.get("base_url") or definition.default_base_url or "").strip(),
         "MPT_LLM_MODEL_NAME": str(card.get("model") or "").strip(),
-        "MPT_PEXELS_API_KEY": str(settings.get("pexels_api_key") or "").strip(),
+        "MPT_PEXELS_API_KEY": source_keys[0] if route == "pexels" and source_keys else "",
+        "MPT_PEXELS_API_KEYS": json.dumps(source_keys, ensure_ascii=False) if route == "pexels" and source_keys else "",
+        "MPT_PIXABAY_API_KEY": source_keys[0] if route == "pixabay" and source_keys else "",
+        "MPT_PIXABAY_API_KEYS": json.dumps(source_keys, ensure_ascii=False) if route == "pixabay" and source_keys else "",
     }
     for key, value in env_values.items():
         if value:
@@ -356,10 +680,14 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
         command.extend(["--root", str(configured_root)])
     command.extend(["--subject", subject])
     generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    command.extend(_moneyprinter_cli_args(task, route))
     if str(generation_settings.get("voiceover_mode") or "").strip().casefold() == "upload":
         voiceover_file = Path(str(generation_settings.get("voiceover_file") or "").strip()).expanduser()
         if not str(voiceover_file) or not voiceover_file.is_file() or voiceover_file.stat().st_size <= 0:
-            raise PipelineError("O modo Upload foi seleccionado, mas não existe um ficheiro de narração válido. Carregue o áudio em Configurações de áudio.")
+            message = "O modo Upload foi seleccionado, mas não existe um ficheiro de narração válido. Carregue o áudio em Configurações de áudio."
+            metadata = _failure_attribution(task, settings, "video", error=message)
+            metadata.update({"failure_api": "Ficheiro local", "failure_provider": "local_storage", "failure_service": "Áudio de narração", "failure_config_fields": "voiceover_file"})
+            raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
         command.extend(["--custom-audio-file", str(voiceover_file.resolve())])
     output_lines: list[str] = []
     line_queue: queue.Queue[str | None] = queue.Queue()
@@ -386,7 +714,10 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
             bufsize=1,
         )
     except FileNotFoundError as exc:
-        raise PipelineError("O comando uv não está instalado; não foi possível iniciar a geração de vídeo.") from exc
+        message = "O comando uv não está instalado; não foi possível iniciar a geração de vídeo."
+        metadata = _failure_attribution(task, settings, "video", error=message)
+        metadata.update({"failure_service": "Runtime MoneyPrinterTurbo"})
+        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata) from exc
 
     reader = threading.Thread(target=_read_output, name=f"mpt-output-{task.get('id', 'video')}", daemon=True)
     reader.start()
@@ -429,7 +760,9 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 break
             if elapsed >= VIDEO_TIMEOUT_SECONDS:
                 _stop_process(process)
-                raise PipelineError(f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada.")
+                message = f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada."
+                metadata = _failure_attribution(task, settings, "video", error=message)
+                raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     finally:
         reader.join(timeout=2)
         _persist_video_diagnostics(task, "\n".join(output_lines))
@@ -439,10 +772,14 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     output = "\n".join(output_lines)
     _persist_video_diagnostics(task, output)
     if result_code == 10:
-        raise PipelineError("A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo.")
+        metadata = _failure_attribution(task, settings, "video", output=output)
+        message = "A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo"
+        raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     if result_code != 0:
         detail = _redact_helper_output(output[-1200:]).strip() or "erro sem detalhes devolvidos pelo helper"
-        raise PipelineError(f"MoneyPrinterTurbo falhou na etapa Vídeo: {detail}")
+        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)
     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:
@@ -455,7 +792,9 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
             except (OSError, json.JSONDecodeError):
                 video_path = None
     if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
-        raise PipelineError("MoneyPrinterTurbo terminou sem devolver um MP4 válido.")
+        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)
     return video_path
 
 
@@ -516,8 +855,9 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     channel = _channel_for_task(task)
     settings = _settings()
     blueprint = _blueprint_for_channel(channel)
+    route = _normalise_video_route(task, settings)
     topic = str(task.get("topic") or "").strip()
-    if not topic or str(task.get("topic_source") or "") in {"auto", "llm_pending"}:
+    if route != "music" and (not topic or str(task.get("topic_source") or "") in {"auto", "llm_pending"}):
         _update(task_id, stage="topic", state="doing", progress=5, error=None)
         topic_result = generate_topic_for_channel(settings, channel, blueprint, user_context=str(task.get("topic_context") or ""))
         topic = str(topic_result.get("topic") or "").strip()
@@ -527,6 +867,32 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
 
     generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
     artifacts = dict(task.get("artifacts") or {})
+    if route == "music":
+        # Apenas Música não é uma tarefa de vídeo: reutiliza o áudio preparado e
+        # termina pronta para a integração de upload musical, sem chamar LLM,
+        # Pexels/Pixabay, MoviePy de vídeo, thumbnail ou upload de vídeo.
+        music_candidates = [
+            task.get("music_path"),
+            generation_settings.get("music_path"),
+            artifacts.get("music"),
+        ]
+        music_path = next((path for path in (_valid_audio_artifact(item) for item in music_candidates) if path is not None), None)
+        if music_path is None:
+            raise PipelineError("A fonte Apenas Música exige um ficheiro de áudio local válido ou uma música Suno já descarregada antes de criar a tarefa.")
+        artifacts["music"] = str(music_path)
+        _update(
+            task_id,
+            stage="upload",
+            state="done",
+            progress=100,
+            artifacts=artifacts,
+            music_ready=True,
+            video_ready=False,
+            thumbnail_status="not_applicable",
+            error=None,
+        )
+        return _task_by_id(task_id) or task
+
     script = _read_persisted_script(task, channel, blueprint, topic)
     if script is None:
         _update(task_id, stage="script", state="doing", progress=18, error=None)
@@ -618,18 +984,33 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     existing_video = _valid_artifact_path(artifacts.get("video"))
     if existing_video is None:
         _update(task_id, stage="video", state="doing", progress=max(52, int(task.get("progress") or 0)), error=None)
-        video_cards = media_cards_for_pool(settings, "video")
-        if bool(settings.get("media_video_pool_enabled")) and video_cards:
-            try:
-                video_prompt = _append_generation_constraints(
-                    f"Título: {title}\n\nRoteiro:\n{str(script.get('content') or '')[:12000]}",
-                    kind="video",
+        try:
+            video_prompt = _append_generation_constraints(
+                f"Título: {title}\n\nRoteiro:\n{str(script.get('content') or '')[:12000]}",
+                kind="video",
+            )
+            if route == "full_ia":
+                video_path = generate_video_from_pool(
+                    settings,
+                    video_prompt,
+                    allowed_providers={"fal_ai", "kie_ai", "agnes"},
                 )
-                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, "title": title})
+            else:
+                video_path = _run_video_helper({
+                    **task,
+                    "topic": topic,
+                    "title": title,
+                    "video_script": str(script.get("content") or ""),
+                    "video_keywords": keywords,
+                    "style_wide": route,
+                })
+        except MediaGenerationError as exc:
+            if route == "full_ia":
+                message = f"Pool Full IA (FAL/KIE AI/Agnes AI): {exc}"
+            else:
+                message = f"Pipeline MoneyPrinterTurbo ({route}): {exc}"
+            metadata = _failure_attribution(task, settings, "video", error=str(exc))
+            raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata) from exc
         current_after_video = _task_by_id(task_id) or {}
         artifacts = dict(current_after_video.get("artifacts") or artifacts)
         artifacts["video"] = str(video_path)
@@ -765,9 +1146,22 @@ def run_once() -> dict[str, Any]:
             message = str(exc)[:2000]
             from hermes_ui.domain import update_task
             current_task = _task_by_id(task_id) or candidate
-            update_task(task_id, {"state": "failed", "error": message, "failed_stage": current_task.get("stage") or "pipeline"})
-            _worker_heartbeat(status="failed", last_error=message, stage=str(current_task.get("stage") or "pipeline"), progress=int(current_task.get("progress") or 0), task_id=task_id)
-            return {"ok": False, "task_id": task_id, "error": message, "recovered_task_ids": recovered}
+            failed_stage = str(current_task.get("stage") or "pipeline")
+            settings = _settings()
+            failure_metadata = dict(getattr(exc, "failure_metadata", {}) or {})
+            if not failure_metadata:
+                failure_metadata = _failure_attribution(current_task, settings, failed_stage, error=message)
+            if "API/provider:" not in message:
+                message = _failure_message(message, failure_metadata)[:2000]
+            failure_updates = {
+                "state": "failed",
+                "error": message,
+                "failed_stage": failed_stage,
+                **failure_metadata,
+            }
+            update_task(task_id, failure_updates)
+            _worker_heartbeat(status="failed", last_error=message, stage=failed_stage, progress=int(current_task.get("progress") or 0), task_id=task_id)
+            return {"ok": False, "task_id": task_id, "error": message, "failure_metadata": failure_metadata, "recovered_task_ids": recovered}
     finally:
         try:
             lock.unlink()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.3.61",
+  "version": "0.3.63",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",
@@ -16,8 +16,6 @@
     "integrations/*.py",
     "integrations/data/*.json",
     "scripts/*.mjs",
-    "storage/blueprints/**/*.json",
-    "storage/tiktok/prompts_master/**/*.md",
     "seed/prompt_masters/**/*.md",
     "seed/blueprints/**/*.json",
     "seed/skills/*.md",

package/seed/skills/mpt_agent.py

@@ -206,7 +206,14 @@ def apply_environment_config(config_path: Path) -> None:
     base_url = os.environ.get("MPT_LLM_BASE_URL", "").strip()
     model_name = os.environ.get("MPT_LLM_MODEL_NAME", "").strip()
     pexels_key = os.environ.get("MPT_PEXELS_API_KEY", "").strip()
-    if not any((provider, llm_key, base_url, model_name, pexels_key)):
+    pixabay_key = os.environ.get("MPT_PIXABAY_API_KEY", "").strip()
+    pexels_keys = _parse_string_list(os.environ.get("MPT_PEXELS_API_KEYS", ""))
+    pixabay_keys = _parse_string_list(os.environ.get("MPT_PIXABAY_API_KEYS", ""))
+    if not pexels_keys and pexels_key:
+        pexels_keys = [pexels_key]
+    if not pixabay_keys and pixabay_key:
+        pixabay_keys = [pixabay_key]
+    if not any((provider, llm_key, base_url, model_name, pexels_keys, pixabay_keys)):
         return
 
     text = config_path.read_text(encoding="utf-8")
@@ -225,9 +232,12 @@ def apply_environment_config(config_path: Path) -> None:
     if model_name:
         text = _replace_config_value(text, f"{provider}_model_name", model_name)
         changes.append(f"{provider}_model_name")
-    if pexels_key:
-        text = _replace_config_value(text, "pexels_api_keys", [pexels_key])
+    if pexels_keys:
+        text = _replace_config_value(text, "pexels_api_keys", pexels_keys)
         changes.append("pexels_api_keys")
+    if pixabay_keys:
+        text = _replace_config_value(text, "pixabay_api_keys", pixabay_keys)
+        changes.append("pixabay_api_keys")
     config_path.write_text(text, encoding="utf-8")
     log("updated configuration fields: " + ", ".join(changes))
 

package/storage/blueprints/importados/demo-content-hermes.json

@@ -1,23 +0,0 @@
-{
-  "id": "demo-content-hermes",
-  "name": "Blueprint de demonstração",
-  "channel_name": "Canal Hermes Demo",
-  "language": "Português",
-  "niche": "Conteúdo faceless educativo",
-  "style": {
-    "wide": "pexels",
-    "shorts": "vertical"
-  },
-  "script": {
-    "target_characters": "7000-9000",
-    "hook_patterns": ["prediction-stakes", "before-after"],
-    "humanization": true
-  },
-  "thumbnail": {
-    "aspect_ratio": "16:9",
-    "max_words": 4,
-    "mobile_test": true
-  },
-  "source": "demo",
-  "version": 1
-}