@danhachuel/thunderbolt 0.3.70 → 0.3.71

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.3.70
+> **Versão deste manual:** 0.3.71
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -35,9 +35,13 @@ O backend local predefinido é **SQLite**, pelo que Personagens e Geração de C
 
 Se pretender trabalhar sem serviço externo, seleccione **SQLite** no selector da aba **Configuração API > AI Influencers**. O caminho `storage/state/ai_influencers.db` e a pasta `storage/influencers/` são geridos internamente, sem campos editáveis para o utilizador. Apenas um backend é usado de cada vez. A base fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; numa actualização normal, personagens, assets e configurações são preservados. O instalador também procura uma base `ai_influencers.db` válida em instalações anteriores do cache npm e recupera-a sem substituir uma base persistente já existente.
 
-Em **AI Influencers > Geração de Conteúdo IA**, utilize as subabas **Imagens**, **Vídeos** e **Motion Control**. Seleccione um personagem, prompt e destinos sociais. A subaba **Imagens** usa o pool de imagem configurado em **Imagem e Video**. A subaba **Vídeos** requer uma imagem inicial e usa o pool de vídeo; escolha o provider/modelo no cartão configurado, sem dependência obrigatória do Veo 3.1. KIE AI, Replicate e FAL AI podem usar tarefas assíncronas; o Thunderbolt consulta o estado e guarda o resultado local antes da revisão. Na Replicate, o campo Modelo deve ser o identificador do modelo ou da versão, e os inputs específicos dependem do modelo configurado.
+Em **AI Influencers > Geração de Conteúdo IA**, utilize as subabas **Imagens** e **Vídeos**. Seleccione um personagem, prompt e provider/modelo configurado no pool correspondente. A subaba **Imagens** usa o pool de imagem configurado em **Imagem e Video IA**. A subaba **Vídeos** requer uma imagem inicial e usa o pool de vídeo; KIE AI, Replicate e FAL AI podem usar tarefas assíncronas. O Thunderbolt consulta o estado e guarda o resultado local antes da revisão. Na Replicate, o campo Modelo deve ser o identificador do modelo ou da versão, e os inputs específicos dependem do modelo configurado.
 
-A geração guarda prompt, caption, provider, modelo, plataforma, estado e caminho do artefacto no backend. **Instagram**, **TikTok**, **YouTube Shorts** e **Facebook** são destinos de revisão; não existe publicação automática nesta primeira adaptação. A publicação só deve ser executada depois de configurar e confirmar a integração social correspondente numa acção separada.
+Em **AI Influencers > Motion Control**, carregue um vídeo original `.mp4` ou `.mov` entre 3 e 30 segundos e uma imagem de referência `.jpg`, `.jpeg` ou `.png` até 10 MB. O prompt é opcional e limitado a 2500 caracteres. O Thunderbolt valida os limites, guarda os originais no storage local, envia-os ao upload temporário oficial KIE, cria `kling-2.6/motion-control`, consulta `/api/v1/jobs/recordInfo` e descarrega o MP4 final localmente. É necessário um cartão KIE AI activo no pool de vídeo. O workflow não utiliza callback público, Telegram, Postiz, Google Drive ou publicação social.
+
+Em **AI Influencers > UGC Products**, carregue a imagem do produto e preencha **Roteiro de vídeo**. Se o roteiro contiver dois blocos separados por `---`, os blocos são usados directamente; nos restantes casos, o pool LLM cria dois prompts de oito segundos, mantendo o produto e proibindo alterações físicas, texto incorporado, legendas e watermark. O Thunderbolt usa o endpoint KIE VEO3.1 `/api/v1/veo/generate` com `veo3_fast`, uma `imageUrls`, `duration: 8` e `resolution: 720p`, consulta `/api/v1/veo/record-info`, descarrega os dois clips e junta-os localmente com FFmpeg. O resultado final e os IDs das tarefas são persistidos no backend AI Influencers; não há Telegram, Postiz, Drive, upload ou publicação social.
+
+A geração standalone guarda prompt, provider, modelo, estado, IDs das tarefas, inputs e caminho do artefacto em conteúdos internos do backend. O proprietário técnico desses registos fica oculto da lista de personagens. Os destinos sociais não são apresentados nestes dois formulários e a publicação permanece fora do workflow.
 
 O runtime do Thunderbolt adapta o comportamento dos workflows do episódio 35, mas não instala nem executa n8n. Formulários, Data Tables, Switch, Wait e subworkflows são substituídos por páginas Streamlit, repository Supabase/SQLite, adapters multimédia, worker, logs e notificações. Nunca coloque API keys nos JSONs dos workflows, em ficheiros versionados ou em mensagens de diagnóstico.
 
@@ -50,7 +54,7 @@ A execução segue sempre **Tema → Script → Título → Keywords (opcional)
 | Opção visível | Rota executada | Resultado esperado |
 |---|---|---|
 | Pexels/Pixabay | MoneyPrinterTurbo stock com a fonte efectiva e as chaves correspondentes | MP4 composto localmente |
-| Full IA | Pool de vídeo limitado a FAL AI, KIE AI e Agnes AI | MP4 gerado pelo provider activo |
+| Full IA | Pool de vídeo limitado pelos cartões activos que declaram capacidade | MP4 gerado pelo provider activo |
 | Apenas Música | Áudio local/Suno já preparado | Ficheiro musical pronto para um upload de música; não gera MP4, thumbnail nem upload YouTube |
 
 Antes de iniciar a rota stock, confirme em **Configurações > Configuração API > Fontes de materiais** que existe pelo menos uma API key para a fonte efectiva. Sem uma key Pexels/Pixabay, o erro é apresentado como configuração da fonte, em vez de uma falha genérica de vídeo. Se o MoneyPrinterTurbo devolver `MPT_NEEDS_INPUT`, o Thunderbolt lê `LLM_PROVIDER`, `MISSING` e `INVALID` e mostra no erro todas as APIs afectadas, como **OpenAI / NVIDIA NIM API + Pexels API**, incluindo os campos que faltam. **Google Lyria não é apresentado como implementado nesta release**; a rota Apenas Música aceita áudio local e a integração Suno existente.

package/README.md

@@ -20,7 +20,7 @@ A primeira versão implementa a camada UI independente com:
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; idiomas históricos preservados e dez códigos MoneyPrinterTurbo com bandeiras; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
 | Upload Música | Subabas **JewelMusic**, **Pushtunes** e **ytmusicapi** para upload de ficheiros, sincronização de bibliotecas e envio autenticado para YouTube Music; credenciais locais e histórico em `uploads.json` |
 | Automação | Menu expansível com a subaba **Automação Youtube**, onde ficam os vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
-| AI Influencers | Menu expansível com Personagens, Geração de Conteúdo IA, Redes Sociais, Tutorial Meta e Tutorial Supabase; Personagens aceita múltiplas imagens e documentos `.md`/`.json`, e Geração de Conteúdo IA separa Imagens, Vídeos e Motion Control |
+| AI Influencers | Menu expansível com Personagens, Geração de Conteúdo IA, Motion Control, UGC Products e Redes Sociais; Personagens aceita múltiplas imagens e documentos `.md`/`.json`, e os dois workflows standalone guardam os resultados localmente sem Telegram ou publicação social |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados, Clip Generator local em Cortes e Editor Python inspirado no PYEdit para vídeos e scripts locais |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, fallback ordenado API Oficial → Upload directo → Postiz, upload de MP4 para Postiz via API key/MCP configurável, TikTok, Instagram e Facebook Pages no front end |
@@ -34,7 +34,11 @@ A área **AI Influencers > Personagens** permite guardar um personagem com nome,
 
 O backend local predefinido é **SQLite**, por isso Personagens e Geração de Conteúdo IA funcionam imediatamente sem credenciais externas. Em **Configurações > Configuração API > AI Influencers**, o selector **Backend da base de dados de AI Influencers** aparece logo abaixo do estado do backend. O card **Supabase** contém apenas **Supabase Project URL** e **Supabase API key**. Se **Supabase** estiver seleccionado mas faltar qualquer uma dessas credenciais, o **Backend activo** muda automaticamente para **SQLite**; quando ambas estão preenchidas, passa para Supabase. O SQLite usa internamente `storage/state/ai_influencers.db` e `storage/influencers/`, sem campos editáveis de caminho ou Storage bucket. O botão **Testar ligação do backend** é read-only e não bloqueia a utilização local. A base SQLite fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; durante uma actualização normal, personagens, assets e configurações são preservados. Se uma versão anterior tiver guardado `ai_influencers.db` no cache npm, o instalador procura uma cópia válida e recupera-a sem substituir uma base persistente já existente.
 
-A página **AI Influencers > Geração de Conteúdo IA** contém as subabas **Imagens**, **Vídeos** e **Motion Control**. Imagens usam os cartões activos do **Pool Imagem**; Vídeos usam os cartões activos do **Pool Vídeo** e exigem uma imagem inicial image-to-video. O selector de modelo não está preso ao Veo 3.1: pode utilizar KIE AI, Replicate, FAL AI, Pollinations ou outro cartão que declare suporte para vídeo. Para Replicate, o campo Modelo deve conter o identificador aceito pela API, como `owner/model` ou `owner/model:version`; a tarefa usa `POST /v1/predictions`, consulta o estado assíncrono e guarda o resultado localmente. A publicação para Instagram, TikTok, YouTube Shorts ou Facebook não é automática: os destinos são registados para revisão e o envio exige uma acção posterior explícita.
+A página **AI Influencers > Geração de Conteúdo IA** contém as subabas **Imagens** e **Vídeos**. Imagens usam os cartões activos do **Pool Imagem**; Vídeos usam os cartões activos do **Pool Vídeo** e exigem uma imagem inicial image-to-video. O selector de modelo não está preso ao Veo 3.1: pode utilizar KIE AI, Replicate, FAL AI, Pollinations ou outro cartão que declare suporte para vídeo. Para Replicate, o campo Modelo deve conter o identificador aceito pela API, como `owner/model` ou `owner/model:version`; a tarefa usa `POST /v1/predictions`, consulta o estado assíncrono e guarda o resultado localmente. A publicação para Instagram, TikTok, YouTube Shorts ou Facebook não é automática.
+
+A página **AI Influencers > Motion Control** adapta apenas a criação do workflow Kling 2.6 Motion Control. O formulário recebe um vídeo original `.mp4`/`.mov` de 3–30 segundos, uma imagem `.jpg`/`.jpeg`/`.png` até 10 MB e um prompt opcional até 2500 caracteres. Os ficheiros são preservados no storage local, enviados temporariamente para o upload oficial KIE e usados em `POST /api/v1/jobs/createTask`; o estado é consultado em `/api/v1/jobs/recordInfo`, o MP4 é descarregado imediatamente e a tarefa é guardada no backend AI Influencers. Não existe callback público, Telegram, Postiz, Google Drive, upload ou publicação social.
+
+A página **AI Influencers > UGC Products** adapta somente a criação do workflow Gemini/VEO3. Recebe uma imagem local do produto e o campo **Roteiro de vídeo**. Um roteiro dividido por `---` é respeitado directamente; caso contrário, o pool LLM estrutura dois prompts com regras de continuidade, preservação do produto, acções fisicamente possíveis e sem texto incorporado, legendas ou watermark. Cada segmento usa `POST /api/v1/veo/generate` com `veo3_fast`, `imageUrls`, `duration: 8` e `resolution: 720p`; o polling usa o endpoint oficial `/api/v1/veo/record-info`. O Thunderbolt descarrega os dois MP4, junta-os localmente com FFmpeg e persiste o artefacto final, sem Telegram, Postiz, Drive ou redes sociais.
 
 A migração é baseada no workflow público [AI Agents A-Z — episódio 35](https://github.com/gyoridavid/ai_agents_az/tree/main/episode_35), mas o runtime do Thunderbolt não instala nem executa n8n. Os formulários, Data Tables, waits e subworkflows são substituídos pela UI Streamlit, pelo repositório dual Supabase/SQLite, pelos adapters multimédia e pelos logs/notificações locais. As API keys são sempre configuradas localmente e não devem ser colocadas nos JSONs do workflow ou no GitHub.
 
@@ -97,7 +101,7 @@ A UI suporta os temas **Dark** e **Light** através do menu nativo de três pont
 
 ## Navegação da UI 0.3.66
 
-A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline Vídeos** é expansível e contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**. **Pipeline Música** é expansível e contém **Criação de Músicas** e **Upload Música**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Geração de Conteúdo IA**, **Redes Sociais**, **Tutorial Meta** e **Tutorial Supabase**, nessa ordem. A página Geração de Conteúdo IA divide-se em **Imagens**, **Vídeos** e **Motion Control**; a subaba Motion Control permanece vazia nesta release.
+A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline Vídeos** é expansível e contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**. **Pipeline Música** é expansível e contém **Criação de Músicas** e **Upload Música**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Geração de Conteúdo IA**, **Motion Control**, **UGC Products**, **Redes Sociais**, **Tutorial Meta** e **Tutorial Supabase**, nessa ordem. A criação de Motion Control e UGC Products ocorre nas páginas standalone e guarda os artefactos localmente; não existem tabs duplicadas dentro de Geração de Conteúdo IA.
  **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP**, **Contas Google**, **Notificações**, **Logs** e **Configuração API**, nessa ordem. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
 A subaba **Tutorial Supabase** apresenta o guia de criação das tabelas `plans` e `posts` e do bucket `instagram-images`, com ligação para a fonte original no GitHub. As duas frases promocionais da comunidade foram omitidas. Todas as subabas internas também são localizadas pelo helper nativo de tabs:

package/app/influencers_ui.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 import io
 import json
 from pathlib import Path
@@ -13,14 +14,26 @@ import streamlit as st
 from hermes_ui.influencers import (
     BACKEND_OPTIONS,
     InfluencerBackendError,
+    STANDALONE_CONTENT_INFLUENCER_ID,
     backend_name,
     backend_status,
+    ensure_standalone_content_owner,
     get_repository,
     test_backend,
 )
-from hermes_ui.media_generation import MediaGenerationError, generate_image_for_card, generate_video_for_card
+from hermes_ui.media_generation import (
+    MediaGenerationError,
+    generate_image_for_card,
+    generate_motion_control_video,
+    generate_ugc_product_video,
+    generate_video_for_card,
+    upload_kie_file,
+    validate_motion_control_file,
+)
+from hermes_ui.creative_generation import generate_ugc_segment_prompts
 from hermes_ui.media_providers import media_cards_for_pool, media_provider_definition
 from hermes_ui.notifications import record_notification
+from hermes_ui.storage import STORAGE, ensure_storage
 
 
 CONTENT_STATES = {
@@ -195,7 +208,7 @@ def render_ai_influencer_characters(
 
     with created_characters_tab:
         try:
-            influencers = repository.list_influencers()
+            influencers = [item for item in repository.list_influencers() if str(item.get("id") or "") != STANDALONE_CONTENT_INFLUENCER_ID]
         except Exception:
             st.error("Não foi possível consultar os personagens no backend seleccionado.")
             return
@@ -301,6 +314,170 @@ def _render_content_history(repository: Any, influencer_id: str = "") -> None:
             st.video(str(artifact))
 
 
+def _store_uploaded_file(uploaded: Any, folder: str) -> Path:
+    """Persist an uploaded Streamlit file under storage without trusting its filename."""
+    ensure_storage()
+    original = Path(str(getattr(uploaded, "name", "upload.bin") or "upload.bin")).name
+    safe_name = "".join(char if char.isalnum() or char in ".-_" else "_" for char in original).strip("._") or "upload.bin"
+    content = uploaded.getvalue()
+    if not content:
+        raise MediaGenerationError(f"O ficheiro {safe_name} está vazio.")
+    digest = hashlib.sha256(content).hexdigest()[:16]
+    destination = STORAGE / "influencer_workflows" / folder / f"{digest}-{safe_name}"
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if not destination.exists():
+        destination.write_bytes(content)
+    return destination
+
+
+def _workflow_owner(repository: Any) -> str:
+    return ensure_standalone_content_owner(repository)
+
+
+def _workflow_provider_cards(settings: Mapping[str, Any]) -> list[dict[str, Any]]:
+    return [card for card in media_cards_for_pool(settings, "video") if str(card.get("provider") or "").strip().lower() == "kie_ai"]
+
+
+def render_motion_control(settings: dict[str, Any]) -> None:
+    """Render Kling 2.6 Motion Control creation only; no social delivery is exposed."""
+    st.title("Motion Control")
+    st.caption("Crie um vídeo Kling 2.6 a partir de um vídeo de movimento e de uma imagem de referência. O resultado é descarregado para o storage local; não há Telegram, Postiz, Drive ou publicação social.")
+    repository = _repository(settings)
+    if repository is None:
+        return
+    cards = _workflow_provider_cards(settings)
+    if not cards:
+        st.warning("Active e configure pelo menos um cartão KIE AI no pool de vídeo em Configuração API > API Keys > Imagem e Video IA.")
+        return
+    card_options = [str(card.get("id") or "") for card in cards]
+    with st.form("influencer_motion_control_form"):
+        video_upload = st.file_uploader("Vídeo original de movimento", type=["mp4", "mov"], key="motion_control_video")
+        image_upload = st.file_uploader("Imagem de referência", type=["jpg", "jpeg", "png"], key="motion_control_image")
+        prompt = st.text_area("Prompt (opcional)", height=120, max_chars=2500, placeholder="Descreva como preservar a identidade da imagem e aplicar o movimento…", key="motion_control_prompt")
+        provider_id = st.selectbox("Provider / modelo", card_options, format_func=lambda value: _provider_label(next(card for card in cards if str(card.get("id")) == value)), key="motion_control_provider")
+        generate = st.form_submit_button("Gerar Motion Control", type="primary", use_container_width=True)
+    if generate:
+        if video_upload is None or image_upload is None:
+            st.error("Seleccione o vídeo original e a imagem de referência.")
+            return
+        card = next(card for card in cards if str(card.get("id")) == provider_id)
+        try:
+            video_path = _store_uploaded_file(video_upload, "motion-control-inputs")
+            image_path = _store_uploaded_file(image_upload, "motion-control-inputs")
+            video_info = validate_motion_control_file(video_path, kind="vídeo")
+            image_info = validate_motion_control_file(image_path, kind="imagem")
+            owner_id = _workflow_owner(repository)
+            record = repository.create_content(
+                {
+                    "influencer_id": owner_id,
+                    "content_type": "video",
+                    "prompt": prompt,
+                    "caption": "",
+                    "provider": card.get("provider"),
+                    "model": "kling-2.6/motion-control",
+                    "platform": "",
+                    "state": "running",
+                    "metadata": {
+                        "workflow": "motion_control",
+                        "input_video_path": str(video_path),
+                        "reference_image_path": str(image_path),
+                        "input_video_duration_seconds": video_info.get("duration_seconds"),
+                        "input_video_size_bytes": video_info.get("size_bytes"),
+                        "reference_image_size_bytes": image_info.get("size_bytes"),
+                    },
+                }
+            )
+            with st.spinner("A enviar os inputs para KIE e a aguardar o Kling Motion Control…"):
+                try:
+                    image_url = upload_kie_file(image_path, card, upload_path="thunderbolt/motion-control")
+                    video_url = upload_kie_file(video_path, card, upload_path="thunderbolt/motion-control")
+                    output, task_id = generate_motion_control_video(settings, card, image_url=image_url, video_url=video_url, prompt=prompt)
+                    metadata = {"workflow": "motion_control", "input_video_path": str(video_path), "reference_image_path": str(image_path), "kie_input_urls_temporary": True}
+                    repository.update_content(record["id"], {"state": "completed", "artifact_path": str(output), "provider_request_id": task_id, "metadata": metadata})
+                    record_notification("influencer_content_completed", "Motion Control concluído", "O vídeo Motion Control foi gerado e guardado localmente.", metadata={"content_id": record["id"], "workflow": "motion_control", "provider": card.get("provider")}, dedupe_key=f"influencer-workflow:{record['id']}:completed")
+                    st.success("Motion Control concluído. O vídeo está disponível no histórico local abaixo.")
+                except Exception as exc:
+                    repository.update_content(record["id"], {"state": "failed", "error": str(exc)[:1000]})
+                    record_notification("influencer_content_failed", "Motion Control falhou", f"A criação Motion Control falhou: {str(exc)[:240]}", metadata={"content_id": record["id"], "workflow": "motion_control", "provider": card.get("provider")}, dedupe_key=f"influencer-workflow:{record['id']}:failed")
+                    st.error(f"Não foi possível gerar o Motion Control: {exc}")
+        except (MediaGenerationError, ValueError, OSError) as exc:
+            st.error(str(exc))
+    _render_content_history(repository, STANDALONE_CONTENT_INFLUENCER_ID)
+
+
+def render_ugc_products(settings: dict[str, Any]) -> None:
+    """Render the local product-image to VEO3 workflow without Telegram or social publishing."""
+    st.title("UGC Products")
+    st.caption("Crie um anúncio UGC a partir de uma imagem de produto e de um roteiro local. O workflow gera dois clips VEO3 de 8 segundos e junta-os com FFmpeg no storage local.")
+    repository = _repository(settings)
+    if repository is None:
+        return
+    video_cards = [card for card in _workflow_provider_cards(settings) if str(card.get("model") or "").strip().lower() in {"", "veo3", "veo3_fast", "veo3_lite"}]
+    if not video_cards:
+        st.warning("Active e configure um cartão KIE AI com modelo VEO3 compatível no pool de vídeo em Configuração API > API Keys > Imagem e Video IA.")
+        return
+    image_cards, _ = _provider_options(settings, "image")
+    image_cards = [card for card in image_cards if str(card.get("provider") or "").strip().lower() == "nano_banana"]
+    with st.form("influencer_ugc_products_form"):
+        product_upload = st.file_uploader("Imagem do produto", type=["jpg", "jpeg", "png", "webp"], key="ugc_products_image")
+        script = st.text_area("Roteiro de vídeo", height=180, placeholder="Escreva a demonstração, falas e acções. Para controlar os dois clips manualmente, separe-os com uma linha contendo ---.", key="ugc_products_script")
+        improve_image = st.checkbox("Melhorar a imagem com o provider de imagem activo (opcional)", value=False, key="ugc_products_improve_image")
+        image_provider_id = ""
+        if improve_image and image_cards:
+            image_provider_options = [str(card.get("id") or "") for card in image_cards]
+            image_provider_id = st.selectbox("Provider de melhoria da imagem", image_provider_options, format_func=lambda value: _provider_label(next(card for card in image_cards if str(card.get("id")) == value)), key="ugc_products_image_provider")
+        elif improve_image:
+            st.info("Não existe um provider activo no pool de imagem; será usada a imagem original.")
+        card_options = [str(card.get("id") or "") for card in video_cards]
+        provider_id = st.selectbox("Provider VEO3", card_options, format_func=lambda value: _provider_label(next(card for card in video_cards if str(card.get("id")) == value)), key="ugc_products_video_provider")
+        generate = st.form_submit_button("Gerar UGC Product", type="primary", use_container_width=True)
+    if generate:
+        if product_upload is None:
+            st.error("Seleccione a imagem do produto.")
+            return
+        card = next(card for card in video_cards if str(card.get("id")) == provider_id)
+        try:
+            product_path = _store_uploaded_file(product_upload, "ugc-products-inputs")
+            image_path = product_path
+            if improve_image and image_provider_id:
+                image_card = next(card for card in image_cards if str(card.get("id")) == image_provider_id)
+                with st.spinner("A melhorar a imagem do produto…"):
+                    image_path = generate_image_for_card(settings, image_card, "Melhorar a apresentação fotográfica do mesmo produto sem alterar a embalagem, logótipo, cores, forma ou objectos visíveis. Fundo comercial limpo e luz natural.", topic="UGC Product", reference_image=product_path)
+            prompts = generate_ugc_segment_prompts(settings, script)
+            owner_id = _workflow_owner(repository)
+            record = repository.create_content(
+                {
+                    "influencer_id": owner_id,
+                    "content_type": "video",
+                    "prompt": script,
+                    "caption": "",
+                    "provider": card.get("provider"),
+                    "model": str(card.get("model") or "veo3_fast"),
+                    "platform": "",
+                    "state": "running",
+                    "metadata": {"workflow": "ugc_products", "product_image_path": str(product_path), "effective_image_path": str(image_path), "segment_prompts": prompts, "telegram": False, "social_publish": False},
+                }
+            )
+            with st.spinner("A enviar a imagem para KIE, a gerar os dois clips VEO3 e a juntá-los localmente…"):
+                try:
+                    image_url = upload_kie_file(image_path, card, upload_path="thunderbolt/ugc-products")
+                    output, task_ids = generate_ugc_product_video(settings, card, image_url=image_url, prompts=prompts)
+                    repository.update_content(record["id"], {"state": "completed", "artifact_path": str(output), "provider_request_id": ",".join(task_ids), "metadata": {"workflow": "ugc_products", "product_image_path": str(product_path), "effective_image_path": str(image_path), "segment_prompts": prompts, "task_ids": task_ids, "telegram": False, "social_publish": False}})
+                    record_notification("influencer_content_completed", "UGC Products concluído", "O vídeo UGC Product foi gerado, unido e guardado localmente.", metadata={"content_id": record["id"], "workflow": "ugc_products", "provider": card.get("provider")}, dedupe_key=f"influencer-workflow:{record['id']}:completed")
+                    st.success("UGC Product concluído. O vídeo final está disponível no histórico local abaixo.")
+                    with st.expander("Prompts dos dois segmentos", expanded=False):
+                        for index, prompt_item in enumerate(prompts, start=1):
+                            st.markdown(f"**Segmento {index}**")
+                            st.code(prompt_item)
+                except Exception as exc:
+                    repository.update_content(record["id"], {"state": "failed", "error": str(exc)[:1000]})
+                    record_notification("influencer_content_failed", "UGC Products falhou", f"A criação UGC Products falhou: {str(exc)[:240]}", metadata={"content_id": record["id"], "workflow": "ugc_products", "provider": card.get("provider")}, dedupe_key=f"influencer-workflow:{record['id']}:failed")
+                    st.error(f"Não foi possível gerar o UGC Product: {exc}")
+        except (MediaGenerationError, ValueError, OSError) as exc:
+            st.error(str(exc))
+    _render_content_history(repository, STANDALONE_CONTENT_INFLUENCER_ID)
+
+
 def render_ai_influencer_content(settings: dict[str, Any]) -> None:
     st.title("Geração de Conteúdo IA")
     st.caption("Gere conteúdos para redes sociais a partir de um personagem e dos seus assets. A publicação permanece separada e exige uma acção explícita.")
@@ -308,11 +485,11 @@ def render_ai_influencer_content(settings: dict[str, Any]) -> None:
     if repository is None:
         return
     try:
-        influencers = repository.list_influencers()
+        influencers = [item for item in repository.list_influencers() if str(item.get("id") or "") != STANDALONE_CONTENT_INFLUENCER_ID]
     except Exception:
         st.error("Não foi possível consultar os personagens.")
         return
-    images_tab, videos_tab, motion_tab = st.tabs(["Imagens", "Vídeos", "Motion Control"])
+    images_tab, videos_tab = st.tabs(["Imagens", "Vídeos"])
 
     with images_tab:
         st.subheader("Gerar imagem para redes sociais")
@@ -415,13 +592,11 @@ def render_ai_influencer_content(settings: dict[str, Any]) -> None:
                 selected_id = str(st.session_state.get("content_video_influencer") or options[0])
                 _render_content_history(repository, selected_id)
 
-    with motion_tab:
-        st.subheader("Motion Control")
-        st.info("A subaba Motion Control foi preparada para a próxima evolução. Nenhuma operação é executada nesta versão.")
-
 
 __all__ = [
     "render_ai_influencer_characters",
     "render_ai_influencer_content",
+    "render_motion_control",
+    "render_ugc_products",
     "render_ai_influencers_api_status",
 ]

package/app/main.py

@@ -31,7 +31,7 @@ from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_a
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
 from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset
 from app.modules.niche_finder.summarizer import summarize_items
-from app.influencers_ui import render_ai_influencer_characters, render_ai_influencer_content, render_ai_influencers_api_status
+from app.influencers_ui import render_ai_influencer_characters, render_ai_influencer_content, render_ai_influencers_api_status, render_motion_control, render_ugc_products
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
 from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEditorError, change_speed, editor_manifest, extract_audio, list_edit_records as list_python_editor_records, list_generated_videos, list_scripts, list_video_files, read_script, remove_audio, replace_audio, resize_video, save_edit_record as save_python_editor_record, save_script, store_uploaded_asset, trim_video
@@ -6397,6 +6397,7 @@ def main():
     models_ai_items = [
         ("Personagens", ":material/person:", "Personagens"),
         ("Geração de Conteúdo IA", ":material/auto_awesome:", "Geração de Conteúdo IA"),
+        ("Motion Control", ":material/motion_photos_on:", "Motion Control"),
         ("UGC Products", ":material/shopping_bag:", "UGC Products"),
         ("Redes Sociais", ":material/share:", "Redes Sociais"),
     ]
@@ -6538,7 +6539,8 @@ def main():
             language_normalizer=normalize_video_language,
         ),
         "Geração de Conteúdo IA": lambda: render_ai_influencer_content(read_json("settings.json", {})),
-        "UGC Products": lambda: render_edit_placeholder("UGC Products", ""),
+        "Motion Control": lambda: render_motion_control(read_json("settings.json", {})),
+        "UGC Products": lambda: render_ugc_products(read_json("settings.json", {})),
         "Redes Sociais": lambda: render_edit_placeholder("Redes Sociais", "Área reservada para a futura funcionalidade de redes sociais."),
         "Analista Growth Youtube": lambda: render_edit_placeholder("Analista Growth Youtube", ""),
         "Analista Growth Tiktok": lambda: render_edit_placeholder("Analista Growth Tiktok", ""),

package/hermes_ui/creative_generation.py

@@ -481,3 +481,42 @@ def generate_creative_package(
         "topic_source": "llm",
         "generated_by": "configured_llm",
     }
+
+
+UGC_SEGMENT_SYSTEM_PROMPT = (
+    "És um realizador de anúncios UGC de produto. Responde apenas com JSON válido no formato "
+    "{\"segments\":[{\"prompt\":\"...\"},{\"prompt\":\"...\"}]}. "
+    "Cria exactamente dois prompts para clips consecutivos de 8 segundos cada. "
+    "Preserva exactamente o produto, embalagem, cores, logótipo e objectos visíveis na imagem; não inventes, removas ou alteres características. "
+    "Descreve apenas acções fisicamente possíveis, continuidade visual entre segmentos, diálogo natural quando solicitado e nenhuma legenda, texto incorporado, watermark ou interface."
+)
+
+
+def _ugc_fallback_prompts(instructions: str) -> list[str]:
+    base = str(instructions or "Apresentar o produto de forma clara, natural e convincente.").strip()
+    return [
+        f"Clip UGC 1 de 8 segundos. {base} Mostrar o produto exactamente como aparece na imagem, com enquadramento estável, luz natural e uma demonstração inicial fisicamente possível. Sem texto no vídeo, sem legendas e sem watermark.",
+        f"Clip UGC 2 de 8 segundos, continuidade directa do clip anterior. {base} Completar a demonstração com uma reacção humana natural e uma apresentação final do produto, sem alterar os objectos visíveis. Sem texto no vídeo, sem legendas e sem watermark.",
+    ]
+
+
+def generate_ugc_segment_prompts(settings: dict[str, Any], instructions: str) -> list[str]:
+    """Return exactly two safe VEO prompts, accepting an explicit `---` split without LLM."""
+    clean = str(instructions or "").strip()
+    explicit = [part.strip() for part in re.split(r"\n\s*(?:---|===|SEGMENTO\s*2)\s*\n", clean, flags=re.IGNORECASE) if part.strip()]
+    if len(explicit) == 2:
+        return [
+            f"Clip UGC 1 de 8 segundos. {explicit[0]} Preserve a imagem do produto. Sem texto, legendas ou watermark.",
+            f"Clip UGC 2 de 8 segundos, em continuidade. {explicit[1]} Preserve a imagem do produto. Sem texto, legendas ou watermark.",
+        ]
+    try:
+        result = _chat_json(settings, UGC_SEGMENT_SYSTEM_PROMPT, clean or "Cria uma demonstração UGC curta e natural do produto.")
+        raw_segments = result.get("segments")
+        if isinstance(raw_segments, list):
+            prompts = [str(item.get("prompt") or "").strip() for item in raw_segments if isinstance(item, dict)]
+            prompts = [item for item in prompts if item]
+            if len(prompts) >= 2:
+                return [f"{item} Sem texto incorporado, sem legendas e sem watermark." for item in prompts[:2]]
+    except CreativeGenerationError:
+        pass
+    return _ugc_fallback_prompts(clean)

package/hermes_ui/influencers.py

@@ -20,6 +20,7 @@ from typing import Any, Iterable, Mapping
 from .storage import ROOT, STORAGE
 
 BACKEND_OPTIONS = ("Supabase", "SQLite")
+STANDALONE_CONTENT_INFLUENCER_ID = "__standalone_ai_content__"
 IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp", ".gif"}
 DOCUMENT_EXTENSIONS = {".md", ".json"}
 ASSET_EXTENSIONS = IMAGE_EXTENSIONS | DOCUMENT_EXTENSIONS
@@ -516,6 +517,22 @@ class SupabaseInfluencerRepository:
         return self._data(response)
 
 
+def ensure_standalone_content_owner(repository: Any) -> str:
+    """Return a hidden owner row for AI content that has no character dependency."""
+    existing = repository.get_influencer(STANDALONE_CONTENT_INFLUENCER_ID)
+    if existing:
+        return STANDALONE_CONTENT_INFLUENCER_ID
+    repository.create_influencer(
+        {
+            "id": STANDALONE_CONTENT_INFLUENCER_ID,
+            "name": "__Thunderbolt AI content__",
+            "bio": "Internal owner for standalone Motion Control and UGC Products content.",
+            "language": "",
+        }
+    )
+    return STANDALONE_CONTENT_INFLUENCER_ID
+
+
 def sqlite_path_from_settings(settings: Mapping[str, Any]) -> Path:
     raw = str(settings.get("influencer_sqlite_path") or "storage/state/ai_influencers.db").strip()
     return _resolve_sqlite_path(raw)
@@ -567,12 +584,14 @@ __all__ = [
     "DOCUMENT_EXTENSIONS",
     "IMAGE_EXTENSIONS",
     "InfluencerBackendError",
+    "STANDALONE_CONTENT_INFLUENCER_ID",
     "SQLiteInfluencerRepository",
     "SupabaseInfluencerRepository",
     "SQLITE_SCHEMA",
     "backend_name",
     "backend_status",
     "get_repository",
+    "ensure_standalone_content_owner",
     "parse_document",
     "sqlite_path_from_settings",
     "test_backend",

package/hermes_ui/media_generation.py

@@ -9,6 +9,12 @@ from __future__ import annotations
 
 import base64
 import binascii
+import json
+import mimetypes
+import os
+import shutil
+import subprocess
+import tempfile
 import time
 from pathlib import Path
 from typing import Any, Mapping
@@ -544,3 +550,332 @@ def generate_video_from_pool(
             if not _is_retryable_media_error(exc):
                 raise
     raise MediaGenerationError("Todos os providers do pool de vídeo falharam: " + " | ".join(errors))
+
+
+KIE_FILE_UPLOAD_ENDPOINT = "https://kieai.redpandaai.co/api/file-stream-upload"
+KIE_MOTION_MODEL = "kling-2.6/motion-control"
+KIE_MOTION_IMAGE_MAX_BYTES = 10 * 1024 * 1024
+KIE_MOTION_VIDEO_MAX_BYTES = 100 * 1024 * 1024
+KIE_MOTION_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png"}
+KIE_MOTION_VIDEO_EXTENSIONS = {".mp4", ".mov"}
+KIE_VEO_MODELS = {"veo3", "veo3_fast", "veo3_lite"}
+
+
+def _require_kie_card(card: Mapping[str, Any]) -> dict[str, Any]:
+    current = dict(card)
+    if str(current.get("provider") or "").strip().lower() != "kie_ai":
+        raise MediaGenerationError("Este workflow requer um cartão KIE AI activo no pool de vídeo.")
+    if not _api_key(current):
+        raise MediaGenerationError("Configure a API key do KIE AI em Configuração API > API Keys > Imagem e Video IA.")
+    return current
+
+
+def _kie_json_error(payload: Any, *, fallback: str) -> ProviderCallError | None:
+    if not isinstance(payload, Mapping):
+        return ProviderCallError(fallback, category="payload", retryable=False)
+    try:
+        code = int(payload.get("code", 200))
+    except (TypeError, ValueError):
+        code = 200
+    if code == 200:
+        return None
+    category = "quota" if code in {402, 429, 433} else "credential" if code == 401 else "endpoint_or_model" if code in {404, 455, 505} else "transient" if code >= 500 else "payload"
+    return ProviderCallError(str(payload.get("msg") or fallback)[:500], status_code=code, category=category, retryable=category in {"quota", "transient"})
+
+
+def validate_motion_control_file(path: str | Path, *, kind: str) -> dict[str, Any]:
+    """Validate KIE Motion Control local input limits before uploading it."""
+    candidate = Path(path).expanduser()
+    if not candidate.is_file():
+        raise MediaGenerationError(f"O ficheiro de {kind} não está disponível.")
+    suffix = candidate.suffix.lower()
+    if kind == "imagem":
+        allowed, maximum = KIE_MOTION_IMAGE_EXTENSIONS, KIE_MOTION_IMAGE_MAX_BYTES
+    elif kind == "vídeo":
+        allowed, maximum = KIE_MOTION_VIDEO_EXTENSIONS, KIE_MOTION_VIDEO_MAX_BYTES
+    else:
+        raise MediaGenerationError("Tipo de input Motion Control inválido.")
+    if suffix not in allowed:
+        raise MediaGenerationError(f"O {kind} Motion Control deve estar em {', '.join(sorted(allowed))}.")
+    size = candidate.stat().st_size
+    if size <= 0:
+        raise MediaGenerationError(f"O ficheiro de {kind} está vazio.")
+    if size > maximum:
+        raise MediaGenerationError(f"O ficheiro de {kind} excede o limite KIE de {maximum // (1024 * 1024)} MB.")
+    duration = None
+    if kind == "vídeo":
+        ffprobe = shutil.which("ffprobe")
+        if not ffprobe:
+            raise MediaGenerationError("Não foi possível verificar a duração do vídeo Motion Control: instale FFmpeg/ffprobe e tente novamente.")
+        try:
+            probe = subprocess.run(
+                [ffprobe, "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", str(candidate)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False,
+            )
+            duration = float(probe.stdout.strip())
+        except (OSError, ValueError, subprocess.TimeoutExpired) as exc:
+            raise MediaGenerationError("Não foi possível verificar a duração do vídeo Motion Control com ffprobe.") from exc
+        if duration < 3 or duration > 30:
+            raise MediaGenerationError(f"O vídeo Motion Control deve ter entre 3 e 30 segundos; o ficheiro tem {duration:.1f}s.")
+    return {"path": str(candidate), "name": candidate.name, "size_bytes": size, "extension": suffix, "duration_seconds": duration}
+
+
+def upload_kie_file(path: str | Path, card: Mapping[str, Any], *, upload_path: str = "thunderbolt/influencers") -> str:
+    """Upload one local file to KIE's temporary public file store using the selected card."""
+    current = _require_kie_card(card)
+    candidate = Path(path).expanduser()
+    if not candidate.is_file():
+        raise MediaGenerationError("O ficheiro seleccionado não está disponível para upload KIE.")
+    mime = mimetypes.guess_type(candidate.name)[0] or "application/octet-stream"
+    try:
+        with candidate.open("rb") as handle:
+            response = requests.post(
+                KIE_FILE_UPLOAD_ENDPOINT,
+                headers={"Authorization": f"Bearer {_api_key(current)}"},
+                files={"file": (candidate.name, handle, mime)},
+                data={"uploadPath": upload_path, "fileName": candidate.name},
+                timeout=300,
+            )
+    except requests.RequestException as exc:
+        raise MediaGenerationError(f"Falha no upload temporário do ficheiro para KIE: {str(exc)[:220]}") from exc
+    if response.status_code >= 400:
+        raise MediaGenerationError(f"O upload temporário KIE devolveu HTTP {response.status_code}.")
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise MediaGenerationError("O upload temporário KIE devolveu uma resposta inválida.") from exc
+    error = _kie_json_error(payload, fallback="O upload temporário KIE falhou.")
+    if error:
+        raise MediaGenerationError(str(error))
+    data = payload.get("data") if isinstance(payload, Mapping) else None
+    url = str((data or {}).get("downloadUrl") or (data or {}).get("fileUrl") or payload.get("downloadUrl") or payload.get("fileUrl") or "").strip() if isinstance(payload, Mapping) else ""
+    if not url.startswith(("http://", "https://")):
+        raise MediaGenerationError("O upload KIE terminou sem devolver um URL público temporário.")
+    return url
+
+
+def _download_video_url(url: str, destination: Path, *, card: Mapping[str, Any] | None = None) -> Path:
+    try:
+        response = requests.get(url, headers=_headers(card or {}) if card else {}, timeout=300)
+        response.raise_for_status()
+    except requests.RequestException as exc:
+        raise MediaGenerationError(f"Não foi possível descarregar o vídeo gerado: {str(exc)[:220]}") from exc
+    if not response.content:
+        raise MediaGenerationError("O provider devolveu um vídeo vazio.")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_bytes(response.content)
+    return destination
+
+
+def _kie_result_urls(value: Any) -> list[str]:
+    if isinstance(value, str):
+        raw = value.strip()
+        try:
+            value = json.loads(raw)
+        except json.JSONDecodeError:
+            value = [raw] if raw.startswith(("http://", "https://")) else []
+    if isinstance(value, Mapping):
+        value = value.get("resultUrls") or value.get("result_urls") or value.get("urls") or []
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip().startswith(("http://", "https://"))]
+
+
+def _poll_kie_task(card: Mapping[str, Any], task_id: str, *, endpoint: str, attempts: int = 40, interval_seconds: float = 5.0, veo: bool = False) -> list[str]:
+    base = _base_url(card) or "https://api.kie.ai/api/v1"
+    url = f"{base}{endpoint}"
+    for index in range(max(1, attempts)):
+        try:
+            response = requests.get(url, headers=_headers(card), params={"taskId": task_id}, timeout=60)
+            if response.status_code >= 400:
+                category = "quota" if response.status_code == 429 else "transient" if response.status_code >= 500 else "endpoint_or_model"
+                raise ProviderCallError(f"Consulta KIE devolveu HTTP {response.status_code}.", status_code=response.status_code, category=category, retryable=category in {"quota", "transient"})
+            payload = response.json()
+        except requests.RequestException as exc:
+            raise ProviderCallError(f"Falha ao consultar a tarefa KIE: {str(exc)[:220]}", category="transient", retryable=True) from exc
+        error = _kie_json_error(payload, fallback="A consulta KIE devolveu um erro.")
+        if error:
+            raise error
+        data = payload.get("data") if isinstance(payload, Mapping) and isinstance(payload.get("data"), Mapping) else {}
+        if veo:
+            flag = data.get("successFlag")
+            if str(flag) in {"2", "3"}:
+                raise ProviderCallError(str(data.get("errorMessage") or payload.get("msg") or "A tarefa VEO falhou."), category="provider", retryable=False)
+            response_data = data.get("response") if isinstance(data.get("response"), Mapping) else {}
+            urls = _kie_result_urls(response_data.get("resultUrls") or data.get("resultUrls"))
+            if str(flag) == "1" and urls:
+                return urls
+        else:
+            state = str(data.get("state") or payload.get("state") or "").lower()
+            if state in {"fail", "failed", "error", "cancelled", "canceled"}:
+                raise ProviderCallError(str(data.get("failMsg") or payload.get("msg") or "A tarefa KIE falhou."), category="provider", retryable=False)
+            urls = _kie_result_urls(data.get("resultJson"))
+            if state == "success" and urls:
+                return urls
+        if index + 1 < attempts:
+            time.sleep(max(0.2, interval_seconds))
+    raise ProviderCallError("A tarefa KIE não concluiu dentro do limite de polling local.", category="transient", retryable=True)
+
+
+def generate_motion_control_video(
+    settings: Mapping[str, Any],
+    card: Mapping[str, Any],
+    *,
+    image_url: str,
+    video_url: str,
+    prompt: str = "",
+    output_path: Path | None = None,
+) -> tuple[Path, str]:
+    """Create a Kling 2.6 Motion Control video and download it locally."""
+    current = _require_kie_card(card)
+    if not image_url.startswith(("http://", "https://")) or not video_url.startswith(("http://", "https://")):
+        raise MediaGenerationError("Motion Control requer URLs KIE acessíveis para a imagem e o vídeo enviados.")
+    clean_prompt = str(prompt or "").strip()
+    if len(clean_prompt) > 2500:
+        raise MediaGenerationError("O prompt Motion Control não pode exceder 2500 caracteres.")
+    base = _base_url(current) or "https://api.kie.ai/api/v1"
+    body: dict[str, Any] = {
+        "model": KIE_MOTION_MODEL,
+        "input": {
+            "prompt": clean_prompt or "Preserve a identidade visual da imagem de referência e aplique os movimentos do vídeo de forma natural, estável e fisicamente plausível.",
+            "input_urls": [image_url],
+            "video_urls": [video_url],
+            "character_orientation": "video",
+            "mode": "720p",
+        },
+    }
+
+    def request(_: dict[str, Any]) -> Any:
+        response = requests.post(f"{base}/jobs/createTask", headers=_headers(current), json=body, timeout=180)
+        if response.status_code < 400:
+            try:
+                payload = response.json()
+            except ValueError:
+                payload = {}
+            error = _kie_json_error(payload, fallback="A criação Motion Control KIE falhou.")
+            if error:
+                raise error
+        return response
+
+    try:
+        routed = route_json_request(settings, pool=POOL_VIDEO, cards=[current], request=request)
+        data = routed.payload.get("data") if isinstance(routed.payload.get("data"), Mapping) else {}
+        task_id = str(data.get("taskId") or routed.payload.get("taskId") or "").strip()
+        if not task_id:
+            raise MediaGenerationError("KIE aceitou Motion Control mas não devolveu taskId.")
+        urls = _poll_kie_task(routed.card, task_id, endpoint="/jobs/recordInfo", veo=False)
+    except (ProviderRoutingError, ProviderCallError) as exc:
+        raise MediaGenerationError(str(exc)) from exc
+    destination = output_path or (STORAGE / "influencer_workflows" / f"motion-control-{task_id}.mp4")
+    return _download_video_url(urls[0], destination, card=routed.card), task_id
+
+
+def generate_ugc_segment(
+    settings: Mapping[str, Any],
+    card: Mapping[str, Any],
+    *,
+    image_url: str,
+    prompt: str,
+    output_path: Path,
+    duration: int = 8,
+) -> tuple[Path, str]:
+    """Create one VEO3.1 image-to-video segment through the official KIE endpoint."""
+    current = _require_kie_card(card)
+    if not image_url.startswith(("http://", "https://")):
+        raise MediaGenerationError("UGC Products requer um URL KIE acessível para a imagem do produto.")
+    model = _model(current).lower() or "veo3_fast"
+    if model not in KIE_VEO_MODELS:
+        model = "veo3_fast"
+    if duration not in {4, 6, 8}:
+        raise MediaGenerationError("A duração de um segmento VEO3 deve ser 4, 6 ou 8 segundos.")
+    base = _base_url(current) or "https://api.kie.ai/api/v1"
+    body = {
+        "prompt": str(prompt or "").strip(),
+        "imageUrls": [image_url],
+        "model": model,
+        "aspect_ratio": "16:9",
+        "resolution": "720p",
+        "duration": duration,
+    }
+
+    def request(_: dict[str, Any]) -> Any:
+        response = requests.post(f"{base}/veo/generate", headers=_headers(current), json=body, timeout=180)
+        if response.status_code < 400:
+            try:
+                payload = response.json()
+            except ValueError:
+                payload = {}
+            error = _kie_json_error(payload, fallback="A criação de segmento VEO KIE falhou.")
+            if error:
+                raise error
+        return response
+
+    try:
+        routed = route_json_request(settings, pool=POOL_VIDEO, cards=[current], request=request)
+        data = routed.payload.get("data") if isinstance(routed.payload.get("data"), Mapping) else {}
+        task_id = str(data.get("taskId") or routed.payload.get("taskId") or "").strip()
+        if not task_id:
+            raise MediaGenerationError("KIE aceitou VEO3 mas não devolveu taskId.")
+        urls = _poll_kie_task(routed.card, task_id, endpoint="/veo/record-info", veo=True)
+    except (ProviderRoutingError, ProviderCallError) as exc:
+        raise MediaGenerationError(str(exc)) from exc
+    return _download_video_url(urls[0], output_path, card=routed.card), task_id
+
+
+def concatenate_video_files(paths: list[Path], output_path: Path) -> Path:
+    """Join generated clips locally with FFmpeg, without uploading the result anywhere."""
+    valid = [Path(path) for path in paths if Path(path).is_file()]
+    if not valid:
+        raise MediaGenerationError("Não existem segmentos locais para concatenar.")
+    if len(valid) == 1:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        if valid[0] != output_path:
+            output_path.write_bytes(valid[0].read_bytes())
+        return output_path
+    try:
+        from .metadata_cleaner import _resolve_ffmpeg
+
+        ffmpeg = _resolve_ffmpeg()
+    except Exception as exc:
+        raise MediaGenerationError(str(exc)) from exc
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, manifest_name = tempfile.mkstemp(prefix="ugc-concat-", suffix=".txt", dir=str(output_path.parent))
+    os.close(descriptor)
+    manifest = Path(manifest_name)
+    try:
+        manifest.write_text("\n".join(f"file '{str(path).replace(chr(39), chr(39) + chr(92) + chr(39) + chr(39))}'" for path in valid) + "\n", encoding="utf-8")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        command = [ffmpeg, "-y", "-f", "concat", "-safe", "0", "-i", str(manifest), "-c", "copy", str(output_path)]
+        completed = subprocess.run(command, capture_output=True, text=True, timeout=600, check=False)
+        if completed.returncode != 0:
+            raise MediaGenerationError(f"FFmpeg não conseguiu juntar os segmentos UGC: {completed.stderr[-500:]}")
+    except OSError as exc:
+        raise MediaGenerationError(f"Não foi possível executar FFmpeg para juntar os segmentos UGC: {exc}") from exc
+    finally:
+        manifest.unlink(missing_ok=True)
+    return output_path
+
+
+def generate_ugc_product_video(
+    settings: Mapping[str, Any],
+    card: Mapping[str, Any],
+    *,
+    image_url: str,
+    prompts: list[str],
+    output_path: Path | None = None,
+) -> tuple[Path, list[str]]:
+    """Generate two 8-second KIE VEO3 clips and concatenate them locally."""
+    clean_prompts = [str(item or "").strip() for item in prompts if str(item or "").strip()]
+    if len(clean_prompts) != 2:
+        raise MediaGenerationError("UGC Products requer exactamente dois prompts de segmento.")
+    ensure_storage()
+    destination = output_path or (STORAGE / "influencer_workflows" / f"ugc-products-{abs(hash((image_url, *clean_prompts))) & 0xffffffffffffffff:x}.mp4")
+    segment_paths = [destination.with_name(f"{destination.stem}-segment-{index + 1}.mp4") for index in range(2)]
+    task_ids: list[str] = []
+    for prompt, segment_path in zip(clean_prompts, segment_paths):
+        _, task_id = generate_ugc_segment(settings, card, image_url=image_url, prompt=prompt, output_path=segment_path, duration=8)
+        task_ids.append(task_id)
+    return concatenate_video_files(segment_paths, destination), task_ids

package/package.json

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