Update Dockerfile

Dockerfile

@@ -1,201 +1,308 @@
-# =============================================================================
-# DOCKERFILE - ADUC-SDR: AI Video Suite v4.1.0
-# Base: CUDA 12.8.0 | PyTorch 2.8.0+cu128
-# Otimizado para Hugging Face Spaces com 8x NVIDIA L40S GPUs
-# =============================================================================
-
-# Base CUDA 12.8.0
-FROM nvidia/cuda:12.8.0-devel-ubuntu22.04
-
-# =============================================================================
-# METADADOS
-# =============================================================================
-LABEL maintainer="Carlos Rodrigues dos Santos & Development Partner"
-LABEL description="ADUC-SDR: Production-Ready Multi-GPU AI Video Generation Suite with Wan2.2, SeedVR, LTX, MMAudio"
-LABEL version="4.1.0"
-LABEL cuda_version="12.8.0"
-LABEL python_version="3.10"
-LABEL pytorch_version="2.8.0+cu128"
-LABEL gpu_optimized_for="8x_NVIDIA_L40S"
-
-# Otimizações específicas do sistema
-ENV OMP_NUM_THREADS=8
-ENV MKL_NUM_THREADS=8
-ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
-ENV CUDA_DEVICE_MAX_CONNECTIONS=32
-
-# Cache e Memory Management
-# Unificar PYTORCH_CUDA_ALLOC_CONF em uma linha
-ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
-ENV CUDA_MODULE_LOADING=LAZY
-ENV CUDA_DEVICE_MAX_CONNECTIONS=32
-ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
-
-
-
-# Constantes de Performance para Build
-ENV CUDA_CACHE_MAXSIZE=2147483648
-ENV CUDA_CACHE_DISABLE=0
-ENV TORCH_HOME=/app/.cache/torch
-ENV HF_HOME=/app/.cache/huggingface
-ENV HF_DATASETS_CACHE=/app/.cache/datasets
-
-# Constantes de Memory Management
-ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
-ENV CUDA_LAUNCH_BLOCKING=0
-ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
-
-# Constantes de Model Loading
-ENV TRANSFORMERS_CACHE=/app/.cache/transformers
-ENV DIFFUSERS_CACHE=/app/.cache/diffusers
-ENV MODEL_CACHE_STRATEGY=aggressive
-
-
-# Melhorias de cache/download
-ENV HF_HOME=/app/.cache/huggingface
-ENV TRANSFORMERS_CACHE=/app/.cache/transformers
-ENV DIFFUSERS_CACHE=/app/.cache/diffusers
-ENV HF_DATASETS_CACHE=/app/.cache/datasets
-ENV HF_HUB_ENABLE_HF_TRANSFER=1
-ENV TOKENIZERS_PARALLELISM=false
-
-
-
-# =============================================================================
-# VARIÁVEIS DE AMBIENTE GLOBAIS
-# =============================================================================
-ENV DEBIAN_FRONTEND=noninteractive
-ENV TZ=UTC
-ENV LANG=C.UTF-8
-ENV LC_ALL=C.UTF-8
-ENV PYTHONUNBUFFERED=1
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PIP_NO_CACHE_DIR=1
-ENV PIP_DISABLE_PIP_VERSION_CHECK=1
-
-# Otimizações de CUDA e Build
-ENV NVIDIA_VISIBLE_DEVICES=all
-ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility
-ENV TORCH_CUDA_ARCH_LIST="8.9"
-ENV MAX_JOBS=90
-
-# Caminhos da Aplicação
-ENV APP_HOME=/app
-WORKDIR $APP_HOME
-
-# =============================================================================
-# PACOTES DO SISTEMA E PYTHON 3.10
-# =============================================================================
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-    build-essential cmake git git-lfs curl wget ffmpeg ninja-build \
-    python3.10 python3.10-dev python3.10-distutils python3-pip \
-    && apt-get clean && rm -rf /var/lib/apt/lists/*
-
-RUN ln -sf /usr/bin/python3.10 /usr/bin/python3 && \
-    ln -sf /usr/bin/python3.10 /usr/bin/python && \
-    python3 -m pip install --upgrade pip
-
-# =============================================================================
-# INSTALAÇÃO DE BIBLIOTECAS DE ALTA PERFORMANCE
-# =============================================================================
-
-# 1. Instala PyTorch 2.8.0 e ferramentas de build
-RUN pip -v install \
-    torch>=2.8.0+cu128 \
-    torchvision \
-    torchaudio \
-    --index-url https://download.pytorch.org/whl/cu128 
+# aduc_framework/managers/wan_manager.py
+# WanManager v1.5.3 (Correção final de dispositivo para `device_map="auto"`)
+
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import random
+from typing import List, Any, Optional, Tuple
+
+import numpy as np
+import torch
+from PIL import Image
+import imageio.v2 as imageio
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+
+torch.backends.cuda.matmul.allow_tf32 = True
+
+try:
+    from torch.nn.attention import sdpa_kernel, SDPBackend
+    _SDPA_NEW = True
+except ImportError:
+    _SDPA_NEW = False
+
+from diffusers import FlowMatchEulerDiscreteScheduler
+from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
+from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
+from diffusers.utils.export_utils import export_to_video
+from aduc_framework.utils.callbacks import DenoiseStepLogger
+
+class WanManager:
+    """
+    Gerenciador de produção v1.5.3:
+    - CORREÇÃO: Remove o gerenciamento manual de dispositivos na preparação de tensores
+      para ser totalmente compatível com a automação do `accelerate` e `device_map="auto"`.
+      Resolve os erros "Cannot copy out of meta tensor".
+    - Mantém o `yield` para atualizações em tempo real, os modos I2V e V2V,
+      e toda a lógica de validação robusta.
+    """
+    MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
+    TRANSFORMER_ID = "cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers"
+    MIN_FRAMES_MODEL = 8
+    MAX_FRAMES_MODEL = 81
+    default_negative_prompt = (
+        "bright, overexposed, static, blurry details, text, subtitles, watermark, style, "
+        "artwork, painting, still image, gray scale, worst quality, low quality, jpeg artifacts, "
+        "ugly, deformed, disfigured, missing fingers, extra fingers, poorly drawn hands, "
+        "poorly drawn face, malformed limbs, fused fingers, messy background, three legs, "
+        "too many people, walking backwards."
+    )
     
-RUN pip install  \
-    packaging \
-    ninja \
-    cmake \
-    pybind11 \
-    scikit-build \
-    cython \
-    hf_transfer \
-    numpy==1.24.4 
-
-
-# =============================================================================
-# CLONAGEM E INSTALAÇÃO DOS REPOSITÓRIOS DA APLICAÇÃO
-# =============================================================================
-
-RUN git clone https://github.com/Wan-Video/Wan2.2.git && \
-    #cd Wan2.2 && pip install -v -r requirements.txt && pip install -v -r requirements_s2v.txt && cd .. && \
-    echo "Copiando 'wan' para /app/wan..." && \
-    cp -r Wan2.2/wan /app/wan 
-    
-# VINCIE
-RUN git clone https://github.com/bytedance-seed/VINCIE.git && \
-    #cd VINCIE && pip install -v -r requirements.txt && cd .. && \  
-    #echo "Copiando módulos do SeedVR para /app/..." && \
-    #cp /VINCIE/generate.py /app/VINCIE/ 2>/dev/null || echo "vincie_service.py não encontrado"
-    #cp -r VINCIE /app/VINCIE && \
-    #cp -r VINCIE/projects /app/projects && \
-    #cp -r VINCIE/data /app/data && \
-    cp -r VINCIE/configs/. /app/configs/
-    
-
-# SeedVR
-RUN git clone https://github.com/bytedance-seed/SeedVR.git && \
-    #cd SeedVR && pip install -v -r requirements.txt && cd .. && \
-    #echo "Copiando módulos do SeedVR para /app/..." && \
-    #cp -r SeedVR/common /app/common && \
-    #cp -r SeedVR/projects /app/projects && \
-    #cp -r SeedVR/data /app/data && \
-    cp -r SeedVR/configs_3b /app/configs_3b 
-    
-
-# MMAudio
-#RUN git clone https://github.com/hkchengrex/MMAudio.git && \
-#    cd MMAudio && pip install -v -e . && cd .. && \
-#    echo "Copiando 'mmaudio' para /app/mmaudio..." && \
-#    cp -r MMAudio/mmaudio /app/mmaudio 
-
-# LTX-Video
-RUN git clone https://github.com/Lightricks/LTX-Video.git && \
-    #cd LTX-Video && pip install -v -e .[inference] && cd .. && \
-    echo "Copiando 'ltx_video' para /app/ltx_video..." && \
-    cp -r LTX-Video/ltx_video /app/ltx_video 
-
-# opcionais 
-RUN pip uninstall -y bitsandbytes triton && \
-    pip install -v  bitsandbytes --index-url https://pypi.org/simple/ && \
-    pip install -v  triton
-    
-# =============================================================================
-# INSTALAÇÃO DO RESTANTE DAS DEPENDÊNCIAS
-# =============================================================================
-COPY requirements.txt .
-
-# Instala os pacotes restantes do requirements.txt
-# A linha do flash-attention no arquivo será ignorada se já estiver instalado, mas é bom limpá-la.
-RUN pip install -r requirements.txt
-
-
-# PyTorch cu128 (fixar versões consistentes do mesmo canal)
-RUN pip install --index-url https://download.pytorch.org/whl/cu128 \
-    torch==2.8.0+cu128 torchvision>=0.19.0+cu128 torchaudio>=2.8.0+cu128
-    
-
-
-# =============================================================================
-# COPIA O CÓDIGO DA APLICAÇÃO E CONFIGURA PERMISSÕES
-# =============================================================================
-COPY . .
-
-RUN useradd -m -u 1000 -s /bash appuser && \
-    chown -R appuser:appuser $APP_HOME && \
-    mkdir -p /app && chown -R appuser:appuser /app
-
-USER appuser
-
-# =============================================================================
-# PONTO DE ENTRADA
-# =============================================================================
-RUN chmod +x ./start.sh
-
-ENTRYPOINT ["./start.sh"]
-CMD ["gradio"]
+    def __init__(self) -> None:
+        self._print_env_banner()
+        print("Loading models into memory...")
+        n_gpus = torch.cuda.device_count()
+        max_memory = {i: "43GiB" for i in range(n_gpus)}
+        max_memory["cpu"] = "120GiB"
+        transformer = WanTransformer3DModel.from_pretrained(
+            self.TRANSFORMER_ID, subfolder="transformer", torch_dtype=torch.bfloat16,
+            device_map="auto", max_memory=max_memory
+        )
+        transformer_2 = WanTransformer3DModel.from_pretrained(
+            self.TRANSFORMER_ID, subfolder="transformer_2", torch_dtype=torch.bfloat16,
+            device_map="auto", max_memory=max_memory
+        )
+        self.pipe = WanImageToVideoPipeline.from_pretrained(
+            self.MODEL_ID, transformer=transformer, transformer_2=transformer_2, torch_dtype=torch.bfloat16
+        )
+        self.pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(self.pipe.scheduler.config, shift=32.0)
+
+        print("Applying 8-step Lightning LoRA...")
+        try:
+            self.pipe.load_lora_weights("Kijai/WanVideo_comfy", weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", adapter_name="lightx2v")
+            self.pipe.load_lora_weights("Kijai/WanVideo_comfy", weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", adapter_name="lightx2v_2", load_into_transformer_2=True)
+            self.pipe.set_adapters(["lightx2v", "lightx2v_2"], adapter_weights=[1.0, 1.0])
+            print("Fusing LoRA weights into the main model...")
+            self.pipe.fuse_lora(adapter_names=["lightx2v"], lora_scale=3.0, components=["transformer"])
+            self.pipe.fuse_lora(adapter_names=["lightx2v_2"], lora_scale=1.0, components=["transformer_2"])
+            self.pipe.unload_lora_weights()
+            print("Lightning LoRA successfully fused.")
+        except Exception as e:
+            print(f"[WanManager] AVISO: Falha ao fundir LoRA Lightning: {e}")
+        print("All models loaded. Service is ready.")
+
+    def _print_env_banner(self) -> None:
+        def _safe_get(fn, default="n/a"):
+            try: return fn()
+            except Exception: return default
+
+        torch_ver = getattr(torch, "__version__", "unknown")
+        cuda_rt = getattr(torch.version, "cuda", "unknown")
+        cudnn_ver = _safe_get(lambda: torch.backends.cudnn.version())
+        cuda_ok = torch.cuda.is_available()
+        n_gpu = torch.cuda.device_count() if cuda_ok else 0
+        devs, total_vram, caps = [], [], []
+        if cuda_ok:
+            for i in range(n_gpu):
+                props = torch.cuda.get_device_properties(i)
+                devs.append(f"cuda:{i} {props.name}")
+                total_vram.append(f"{props.total_memory/1024**3:.1f}GiB")
+                caps.append(f"{props.major}.{props.minor}")
+        
+        try: bf16_supported = torch.cuda.is_bf16_supported()
+        except: bf16_supported = False
+        
+        tf32_allowed = torch.backends.cuda.matmul.allow_tf32
+        sdpa_api = "torch.nn.attention (2.1+)" if _SDPA_NEW else "torch.backends.cuda (2.0)" if not _SDPA_NEW and hasattr(torch.backends.cuda, 'sdp_kernel') else "unavailable"
+        
+        try:
+            import xformers
+            xformers_ok = True
+        except ImportError:
+            xformers_ok = False
+
+        alloc_conf = os.environ.get("PYTORCH_CUDA_ALLOC_CONF", "unset")
+        visible = os.environ.get("CUDA_VISIBLE_DEVICES", "unset")
+        python_ver = platform.python_version()
+        nvcc = shutil.which("nvcc")
+        nvcc_ver = "n/a"
+        if nvcc:
+            try: nvcc_ver = subprocess.check_output([nvcc, "--version"], text=True).strip().splitlines()[-1]
+            except Exception: nvcc_ver = "n/a"
+
+        banner_lines = [
+            "================== WAN MANAGER • ENV ==================",
+            f"Python              : {python_ver}", f"PyTorch             : {torch_ver}",
+            f"CUDA (torch)        : {cuda_rt}", f"cuDNN               : {cudnn_ver}",
+            f"CUDA available      : {cuda_ok}", f"GPU count           : {n_gpu}",
+            f"GPUs                : {', '.join(devs) if devs else 'n/a'}",
+            f"GPU VRAM            : {', '.join(total_vram) if total_vram else 'n/a'}",
+            f"Compute Capability  : {', '.join(caps) if caps else 'n/a'}",
+            f"BF16 supported      : {bf16_supported}", f"TF32 allowed        : {tf32_allowed}",
+            f"SDPA API            : {sdpa_api}", f"xFormers available  : {xformers_ok}",
+            f"CUDA_VISIBLE_DEVICES: {visible}", f"PYTORCH_CUDA_ALLOC_CONF: {alloc_conf}",
+            f"nvcc                : {nvcc_ver}",
+            "=======================================================",
+        ]
+        print("\n".join(banner_lines))
+
+    def resize_and_crop_to_match(self, target: Image.Image, ref_w: int, ref_h: int) -> Image.Image:
+        tw, th = target.size
+        s = max(ref_w / tw, ref_h / th)
+        nw, nh = int(tw * s), int(th * s)
+        resized = target.resize((nw, nh), Image.Resampling.LANCZOS)
+        left, top = (nw - ref_w) // 2, (nh - ref_h) // 2
+        return resized.crop((left, top, left + ref_w, top + ref_h))
+
+    def _preprocess_causal_video(self, video_path: str, target_fps: int, target_w: int, target_h: int) -> str:
+        print(f"[WanManager] Pré-processando vídeo: conformando para {target_w}x{target_h} @ {target_fps}fps...")
+        clip = VideoFileClip(video_path)
+        conformed_clip = clip.resize(height=target_h) if (clip.w / clip.h) < (target_w / target_h) else clip.resize(width=target_w)
+        conformed_clip = conformed_clip.crop(x_center=conformed_clip.w/2, y_center=conformed_clip.h/2, width=target_w, height=target_h)
+        conformed_clip = conformed_clip.set_fps(target_fps)
+        with tempfile.NamedTemporaryFile(suffix="_conformed.mp4", delete=False) as tmp:
+            conformed_video_path = tmp.name
+        conformed_clip.write_videofile(conformed_video_path, codec="libx264", audio=False, logger=None, threads=os.cpu_count() or 1)
+        clip.close()
+        print(f"[WanManager] Vídeo conformado salvo em: {conformed_video_path}")
+        return conformed_video_path
+
+    def generate_video(
+        self,
+        convergent_img: Image.Image,
+        causal_video_path: Optional[str] = None,
+        causal_img: Optional[Image.Image] = None,
+        handler_img: Optional[Image.Image] = None,
+        total_frames: Optional[int] = 33,
+        handler_frame: Optional[int] = 17,
+        handler_weight: float = 1.0,
+        causal_weight: float = 1.0,
+        fps: Optional[int] = 16,
+        resolution: Optional[str] = "480x832",
+        prompt: str = "",
+        negative_prompt: Optional[str] = None,
+        steps: int = 8,
+        guidance_scale: float = 1.0,
+        guidance_scale_2: float = 1.0,
+        seed: int = 42,
+        randomize_seed: bool = True,
+    ):
+        final_handler_img, final_causal_img = handler_img, causal_img
+        final_total_frames, final_fps, final_resolution = total_frames, fps, resolution
+        final_handler_frame, final_causal_weight, final_handler_weight = handler_frame, causal_weight, handler_weight
+        conformed_video_path = None
+
+        if causal_video_path and os.path.exists(causal_video_path):
+            print(f"[WanManager] INFO: Modo 'Causal Video' ativado com o arquivo: {causal_video_path}")
+            target_h, target_w = [int(x) for x in resolution.split('x')]
+            conformed_video_path = self._preprocess_causal_video(causal_video_path, fps, target_w, target_h)
+            reader = imageio.get_reader(conformed_video_path)
+            video_frame_count = reader.count_frames()
+            if video_frame_count < 25:
+                reader.close()
+                raise ValueError(f"O vídeo conformado deve ter pelo menos 25 frames. Tem apenas {video_frame_count}.")
+            print("[WanManager] INFO: Extraindo frames de controle do vídeo conformado...")
+            causal_img_from_video_np = reader.get_data(video_frame_count - 25)
+            final_causal_img = Image.fromarray(causal_img_from_video_np)
+            handler_img_from_video_np = reader.get_data(video_frame_count - 1)
+            final_handler_img = Image.fromarray(handler_img_from_video_np)
+            reader.close()
+            final_total_frames, final_fps, final_resolution = video_frame_count, fps, resolution
+            final_handler_frame, final_handler_weight, final_causal_weight = 24, 1.0, causal_weight
+        else:
+            print("[WanManager] INFO: Modo 'Image to Video' padrão ativado.")
+            if convergent_img is None or causal_img is None:
+                raise ValueError("A imagem convergente (inicial) e a imagem causal (final) são obrigatórias no modo I2V.")
+
+        target_h, target_w = [int(x) for x in final_resolution.split('x')]
+        
+        processed_convergent = self.resize_and_crop_to_match(convergent_img, target_w, target_h)
+        processed_causal = self.resize_and_crop_to_match(final_causal_img, target_w, target_h)
+        processed_handler = self.resize_and_crop_to_match(final_handler_img, target_w, target_h) if final_handler_img else None
+
+        clamped_frames = int(np.clip(final_total_frames, self.MIN_FRAMES_MODEL, self.MAX_FRAMES_MODEL))
+        sf_t = getattr(self.pipe, "vae_scale_factor_temporal", 4)
+        num_frames = ((clamped_frames - 1) // sf_t * sf_t) + 1
+        
+        print(f"[WanManager] INFO: Total de frames final para a pipeline é {num_frames}.")
+
+        current_seed = random.randint(0, np.iinfo(np.int32).max) if randomize_seed else int(seed)
+        
+        corrected_handler_index = None
+        if processed_handler is not None and final_handler_frame is not None:
+            min_safe_frame, max_safe_frame = 9, num_frames - 9
+            if causal_video_path:
+                 corrected_handler_index = max(min_safe_frame, min(final_handler_frame, max_safe_frame))
+            else:
+                block_index = round(final_handler_frame / 8)
+                aligned_frame = block_index * 8 + 1
+                corrected_handler_index = max(min_safe_frame, min(aligned_frame, max_safe_frame))
+            print(f"[WanManager] INFO: Handler Frame final validado para {corrected_handler_index}.")
+
+        print("[WanManager] Preparando tensores e timesteps para a geração...")
+        
+        transformer_dtype = self.pipe.transformer.dtype
+        generator = torch.Generator(device="cpu").manual_seed(current_seed)
+        
+        prompt_embeds, negative_prompt_embeds = self.pipe.encode_prompt(prompt=prompt, negative_prompt=negative_prompt or self.default_negative_prompt)
+        prompt_embeds = prompt_embeds.to(transformer_dtype)
+        if negative_prompt_embeds is not None:
+            negative_prompt_embeds = negative_prompt_embeds.to(transformer_dtype)
+            
+        image_processed = self.pipe.video_processor.preprocess(processed_convergent, height=target_h, width=target_w)
+        causal_img_processed = self.pipe.video_processor.preprocess(processed_causal, height=target_h, width=target_w)
+        handler_img_processed = self.pipe.video_processor.preprocess(processed_handler, height=target_h, width=target_w) if processed_handler else None
+
+        latents_outputs = self.pipe.prepare_latents(
+            image=image_processed, batch_size=1, num_channels_latents=self.pipe.vae.config.z_dim,
+            height=target_h, width=target_w, num_frames=num_frames, dtype=torch.float32, generator=generator,
+            causal_img=causal_img_processed, handler_img=handler_img_processed,
+            handler_frame_index=corrected_handler_index, handler_weight=final_handler_weight, causal_weight=final_causal_weight
+        )
+        latents, condition = latents_outputs
+        
+        self.pipe.scheduler.set_timesteps(steps, device=latents.device)
+        timesteps = self.pipe.scheduler.timesteps
+        
+        denoise_logger = DenoiseStepLogger(self.pipe)
+        denoising_step_videos = []
+
+        with torch.no_grad():
+            for i, t in enumerate(timesteps):
+                print(f"[WanManager] Executando passo de denoising {i+1}/{steps}...")
+                latent_model_input = torch.cat([latents, condition], dim=1).to(transformer_dtype)
+                
+                noise_pred_uncond = self.pipe.transformer(latent_model_input, t, encoder_hidden_states=negative_prompt_embeds).sample
+                noise_pred_text = self.pipe.transformer(latent_model_input, t, encoder_hidden_states=prompt_embeds).sample
+                
+                noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+                latents = self.pipe.scheduler.step(noise_pred, t, latents).prev_sample
+
+                video_frames_np = denoise_logger.decode_latents_to_video_tensor(latents)
+                with tempfile.NamedTemporaryFile(suffix=f"_step_{i+1}.mp4", delete=False) as tmp:
+                    step_video_path = tmp.name
+                export_to_video(video_frames_np[0], step_video_path, fps=final_fps)
+                denoising_step_videos.append(step_video_path)
+                
+                yield None, None, denoising_step_videos
+        
+        print("[WanManager] Denoising completo. Processando o vídeo final...")
+        final_video_frames_np = denoise_logger.decode_latents_to_video_tensor(latents)
+
+        with tempfile.NamedTemporaryFile(suffix="_generated_clip.mp4", delete=False) as tmp:
+            generated_clip_path = tmp.name
+        export_to_video(final_video_frames_np[0], generated_clip_path, fps=final_fps)
+        
+        final_video_path = generated_clip_path
+        if conformed_video_path:
+            print("[WanManager] INFO: Modo Causal Video: iniciando concatenação final...")
+            input_clip = VideoFileClip(conformed_video_path)
+            generated_clip = VideoFileClip(generated_clip_path)
+            duration_to_cut = 25 / input_clip.fps
+            if input_clip.duration > duration_to_cut:
+                prefix_clip = input_clip.subclip(0, input_clip.duration - duration_to_cut)
+                final_clip = concatenate_videoclips([prefix_clip, generated_clip])
+            else:
+                final_clip = generated_clip
+            with tempfile.NamedTemporaryFile(suffix="_final.mp4", delete=False) as tmp:
+                final_video_path = tmp.name
+            final_clip.write_videofile(final_video_path, codec="libx264", audio=False, logger=None, threads=os.cpu_count() or 1)
+            input_clip.close()
+            generated_clip.close()
+            os.remove(conformed_video_path)
+            os.remove(generated_clip_path)
+            print(f"[WanManager] INFO: Vídeo final concatenado salvo em: {final_video_path}")
+        
+        yield final_video_path, current_seed, denoising_step_videos