Upload app.py with huggingface_hub

app.py

@@ -1,18 +1,14 @@
 """LTX-2.3 Cinemagraph LoRA — image-to-video demo.
 
-Turns a still image into a looping cinemagraph (selective motion, frozen background)
-using the `Lightricks/LTX-2.3-22b-LoRA-Cinemagraph` LoRA on top of the LTX-2.3-22B base.
-
-Architecture (the 22B base is too large to hold Gemma + the video model together):
-  * Text encoding (Gemma-3-12B + LTX embeddings connectors) runs on a SEPARATE
-    Space `linoyts/ltx23-gemma-encoder-api`, called here via gradio_client. It
-    returns the final positive/negative EmbeddingsProcessorOutput tensors as a .pt.
-  * This Space runs the TI2VidTwoStagesPipeline (dev stage-1 with CFG/STG + distilled
-    LoRA stage-2 with x2 spatial upsample). `encode_prompts` is monkeypatched with the
-    precomputed embeddings so Gemma never loads here.
-  * The Cinemagraph LoRA is loaded into `loras` so it applies to both stages.
-
-Mirrors linoyts/ltx23-dev-api, extended to i2v + the cinemagraph LoRA.
+Turns a still image into a looping cinemagraph: only the element you describe moves
+while the rest of the frame stays frozen (locked-off static camera). Built on the native
+LTX-2.3 `TI2VidTwoStagesPipeline` (dev/base stage 1 with CFG/STG guidance, distilled-LoRA
+stage 2 + x2 spatial upsampler) with the Cinemagraph LoRA fused into stage 1.
+
+Text encoding (positive + negative, for CFG) is offloaded to the Gemma encoder Space
+(TEXT_ENCODER_SPACE) via gradio_client — `encode_prompts` is monkeypatched with the
+precomputed [ctx_p, ctx_n], so this Space never loads Gemma. Mirrors the working
+`linoyts/ltx23-dev-api` backend pattern.
 """
 
 import os
@@ -21,7 +17,6 @@ import sys
 
 os.environ["TORCH_COMPILE_DISABLE"] = "1"
 os.environ["TORCHDYNAMO_DISABLE"] = "1"
-os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 
 subprocess.run([sys.executable, "-m", "pip", "install", "xformers==0.0.32.post2",
                 "--no-build-isolation"], check=False)
@@ -61,11 +56,11 @@ import numpy as np
 import spaces
 from gradio_client import Client, handle_file
 from huggingface_hub import hf_hub_download
-from PIL import Image
+from PIL import Image, ImageOps
 
 import ltx_pipelines.ti2vid_two_stages as ti2vid_module
 from ltx_core.components.guiders import MultiModalGuiderParams
-from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps
+from ltx_core.loader import LoraPathStrengthAndSDOps, LTXV_LORA_COMFY_RENAMING_MAP
 from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number
 from ltx_core.quantization import QuantizationPolicy
 from ltx_core.text_encoders.gemma.embeddings_processor import EmbeddingsProcessorOutput
@@ -127,22 +122,23 @@ def _patched_load(self, path, sd_ops, device=None):
 
 SafetensorsStateDictLoader.load = _patched_load
 
-# --- LoRA-fusion patch for ZeroGPU startup ---
-# On ZeroGPU, module-scope `.to("cuda")` is intercepted (no real GPU is attached
-# yet), but fp8 weights still *report* device="cuda". The cast-only-fp8 LoRA fusion
-# path (`_fuse_delta_with_cast_fp8`) then launches a Triton CUDA kernel at import
-# time, which crashes with "no CUDA-capable device is detected". Force the
-# CPU-style fusion (plain bf16 add + deterministic fp8 downcast) instead — no GPU
-# kernel needed, and the ZeroGPU packing step handles the real device transfer.
+# ZeroGPU LoRA-into-fp8 fusion patch:
+# fuse_loras._fuse_delta_with_cast_fp8 upcasts the fp8 base weight + adds the LoRA delta via a
+# Triton CUDA kernel (calculate_weight_float8 -> fused_add_round_kernel). That kernel launches a
+# *real* CUDA op, which cannot be ZeroGPU-virtualised at module scope and dies with
+# "CUDA error: no CUDA-capable device is detected". Replace it with a pure-torch equivalent
+# (upcast to bf16, add delta, re-cast to fp8) that goes through torch.Tensor ops ZeroGPU can
+# virtualise. dev-api avoids this only because it fuses no user LoRA into the fp8 stage-1 base.
 import ltx_core.loader.fuse_loras as _fuse_mod
 
 
-def _fuse_delta_with_cast_fp8_nogpu(deltas, weight, key, target_dtype, device):
-    deltas.add_(weight.to(dtype=deltas.dtype, device=deltas.device))
-    return {key: deltas.to(dtype=target_dtype)}
+def _fuse_delta_with_cast_fp8_torch(deltas, weight, key, target_dtype, device):
+    fused = (deltas.to(torch.bfloat16) + weight.to(torch.bfloat16)).to(dtype=target_dtype)
+    return {key: fused}
 
 
-_fuse_mod._fuse_delta_with_cast_fp8 = _fuse_delta_with_cast_fp8_nogpu
+_fuse_mod._fuse_delta_with_cast_fp8 = _fuse_delta_with_cast_fp8_torch
+print("[PATCH] fp8 LoRA fusion -> pure-torch (ZeroGPU-virtualisable, no Triton kernel)")
 
 logging.getLogger().setLevel(logging.INFO)
 MAX_SEED = np.iinfo(np.int32).max
@@ -156,39 +152,35 @@ DEFAULT_NEGATIVE = (
     "crawling texture, distorted, blurry, low quality"
 )
 
-# LTX-2.3 Cinemagraph guider defaults (per model card: stg_v scale 1.0, block 29, CFG 4.0).
+# LTX-2.3 guider defaults. Cinemagraph card recommends stg_v scale 1.0 @ block 29, guidance 4.0.
 VIDEO_STG, VIDEO_RESCALE, A2V_SCALE, STG_BLOCKS = 1.0, 0.7, 3.0, [29]
 AUDIO_CFG, AUDIO_STG, AUDIO_RESCALE, V2A_SCALE = 7.0, 1.0, 0.7, 3.0
 
 LTX_REPO = os.environ.get("LTX_REPO", "Lightricks/LTX-2.3")
-LORA_REPO = os.environ.get("LORA_REPO", "Lightricks/LTX-2.3-22b-LoRA-Cinemagraph")
-LORA_FILE = "ltx-2.3-22b-lora-cinemagraph-0.9.safetensors"
 DEV_FILE = "ltx-2.3-22b-dev.safetensors"
 DISTILLED_LORA_FILE = "ltx-2.3-22b-distilled-lora-384-1.1.safetensors"
 UPSCALER_FILE = "ltx-2.3-spatial-upscaler-x2-1.1.safetensors"
+CINEMAGRAPH_REPO = os.environ.get("CINEMAGRAPH_REPO", "Lightricks/LTX-2.3-22b-LoRA-Cinemagraph")
+CINEMAGRAPH_FILE = "ltx-2.3-22b-lora-cinemagraph-0.9.safetensors"
+DEFAULT_LORA_STRENGTH = 1.0
 TOKEN = os.environ.get("HF_TOKEN")
 TEXT_ENCODER_SPACE = os.environ.get("TEXT_ENCODER_SPACE", "linoyts/ltx23-gemma-encoder-api")
 
-# Cinemagraph LoRA strength (0.7-3.0 per model card; 1.0 is a solid default).
-CINEMAGRAPH_LORA_STRENGTH = float(os.environ.get("CINEMAGRAPH_LORA_STRENGTH", "1.0"))
-
 print("Downloading checkpoints…")
 checkpoint_path = hf_hub_download(LTX_REPO, DEV_FILE, token=TOKEN)
 distilled_lora_path = hf_hub_download(LTX_REPO, DISTILLED_LORA_FILE, token=TOKEN)
 upsampler_path = hf_hub_download(LTX_REPO, UPSCALER_FILE, token=TOKEN)
-cinemagraph_lora_path = hf_hub_download(LORA_REPO, LORA_FILE, token=TOKEN)
+cinemagraph_lora_path = hf_hub_download(CINEMAGRAPH_REPO, CINEMAGRAPH_FILE, token=TOKEN)
 
 pipeline = TI2VidTwoStagesPipeline(
     checkpoint_path=checkpoint_path,
     distilled_lora=[LoraPathStrengthAndSDOps(path=distilled_lora_path, strength=1.0, sd_ops=None)],
     spatial_upsampler_path=upsampler_path,
     gemma_root=None,  # text encoding happens on TEXT_ENCODER_SPACE
-    # Cinemagraph LoRA (ComfyUI-format) applied to BOTH stages via `loras`.
+    # Cinemagraph LoRA fused into stage 1 (ComfyUI-format keys -> comfy renaming map).
     loras=[LoraPathStrengthAndSDOps(
-        path=cinemagraph_lora_path,
-        strength=CINEMAGRAPH_LORA_STRENGTH,
-        sd_ops=LTXV_LORA_COMFY_RENAMING_MAP,
-    )],
+        path=cinemagraph_lora_path, strength=DEFAULT_LORA_STRENGTH,
+        sd_ops=LTXV_LORA_COMFY_RENAMING_MAP)],
     quantization=QuantizationPolicy.fp8_cast(),
 )
 
@@ -209,15 +201,19 @@ print("Pipeline ready.")
 _emb_cache = {}
 
 
-def fetch_embeddings(prompt, negative_prompt, enhance_prompt, seed):
-    """Call the Gemma encoder Space; returns {'positive', 'negative', 'final_prompt'}."""
-    key = (prompt, negative_prompt, bool(enhance_prompt), int(seed) if enhance_prompt else 0)
+def fetch_embeddings(prompt, negative_prompt, seed):
+    """Call the Gemma encoder Space; returns {'positive', 'negative', 'final_prompt'}.
+
+    enhance_prompt is disabled: cinemagraph prompting relies on an explicit
+    'only X moves, everything else frozen' structure that prompt-enhancement can dilute.
+    """
+    key = (prompt, negative_prompt)
     if key in _emb_cache:
         return _emb_cache[key]
-    client = Client(TEXT_ENCODER_SPACE, token=TOKEN)
+    client = Client(TEXT_ENCODER_SPACE, token=TOKEN, httpx_kwargs={"timeout": 300})
     emb_file, final_prompt, status = client.predict(
         prompt=prompt, negative_prompt=negative_prompt or "", encode_negative=True,
-        enhance_prompt=enhance_prompt, seed=int(seed), api_name="/encode",
+        enhance_prompt=False, seed=int(seed), api_name="/encode",
     )
     print(f"[encoder] {status} | final prompt: {final_prompt[:80]}…")
     data = torch.load(emb_file, map_location="cpu", weights_only=True)
@@ -235,21 +231,30 @@ def _to_output(pack, device):
     )
 
 
-def gpu_duration(embeddings, image_path, prompt, negative_prompt="", duration=4.0, *args, **kwargs):
-    return min(600, 150 + int(duration) * 45)
+def _prep_image(image_path, width, height):
+    """Aspect-fit/crop the still to WxH and save a temp file the VAE encoder can read."""
+    im = Image.open(image_path).convert("RGB")
+    im = ImageOps.fit(im, (width, height), Image.LANCZOS)
+    tmp = tempfile.mktemp(suffix=".png")
+    im.save(tmp)
+    return tmp
+
+
+def gpu_duration(embeddings, image_path, prompt, negative_prompt="", duration=3.0, *args, **kwargs):
+    return min(600, 150 + int(duration) * 40)
 
 
 @spaces.GPU(duration=gpu_duration)
 @torch.inference_mode()
 def _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration, used_seed,
-                  num_inference_steps, video_cfg_scale, width, height,
+                  num_inference_steps, video_cfg_scale, lora_strength, width, height,
                   progress=gr.Progress(track_tqdm=True)):
     num_frames = ((int(duration * FRAME_RATE) + 1 - 1 + 7) // 8) * 8 + 1
     tiling_config = TilingConfig.default()
     video_chunks_number = get_video_chunks_number(num_frames, tiling_config)
 
-    # i2v: condition on the input image at frame 0 with full strength.
-    images = [ImageConditioningInput(path=image_path, frame_idx=0, strength=1.0)]
+    cond_img = _prep_image(image_path, int(width), int(height))
+    images = [ImageConditioningInput(path=cond_img, frame_idx=0, strength=1.0)]
 
     precomputed = [_to_output(embeddings["positive"], "cuda"),
                    _to_output(embeddings["negative"], "cuda")]
@@ -273,7 +278,7 @@ def _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration, use
                 modality_scale=V2A_SCALE, skip_step=0, stg_blocks=STG_BLOCKS),
             images=images,
             tiling_config=tiling_config,
-            enhance_prompt=False,  # already enhanced on the encoder Space
+            enhance_prompt=False,  # already handled remotely; cinemagraph wants literal prompts
         )
     finally:
         ti2vid_module.encode_prompts = original
@@ -284,127 +289,125 @@ def _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration, use
     return output_path
 
 
-def _round64(x):
-    return max(64, int(round(x / 64)) * 64)
+def _build_prompt(user_prompt: str) -> str:
+    p = (user_prompt or "").strip()
+    if TRIGGER.lower() in p.lower():
+        return p
+    return f"{TRIGGER}, tripod locked-off static camera, zero camera movement, {p}"
 
 
 def generate(
-    image,
+    image: str,
     prompt: str,
     negative_prompt: str = DEFAULT_NEGATIVE,
     duration: float = 4.0,
     seed: int = 42,
-    randomize_seed: bool = False,
+    randomize_seed: bool = True,
     num_inference_steps: int = 30,
     video_cfg_scale: float = 4.0,
+    lora_strength: float = DEFAULT_LORA_STRENGTH,
     width: int = 704,
     height: int = 512,
-    enhance_prompt: bool = True,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """Generate a looping cinemagraph video from a still image.
+    """Turn a still image into a looping cinemagraph (selective motion, everything else frozen).
 
     Args:
-        image: input still image (filepath) to animate.
-        prompt: describes what should move and what should stay frozen. The
-            trigger word CINEMAGRAPH_MOTION is auto-prepended if missing.
-        negative_prompt: things to avoid (camera motion, global movement, etc.).
-        duration: video length in seconds.
+        image: path to the still input image (i2v conditioning at frame 0).
+        prompt: what should move (e.g. "only the ocean waves shimmer in his sunglasses").
+            The CINEMAGRAPH_MOTION trigger + static-camera framing are added automatically.
+        negative_prompt: things to suppress (camera motion, whole-image movement, artifacts).
+        duration: clip length in seconds.
         seed: RNG seed.
-        randomize_seed: pick a new random seed each run.
-        num_inference_steps: stage-1 denoising steps.
-        video_cfg_scale: classifier-free guidance scale.
-        width: output width (rounded to a multiple of 64).
-        height: output height (rounded to a multiple of 64).
-        enhance_prompt: run Gemma prompt enhancement on the encoder Space.
+        randomize_seed: draw a fresh random seed instead of `seed`.
+        num_inference_steps: stage-1 diffusion steps.
+        video_cfg_scale: classifier-free guidance scale (cinemagraph default 4.0).
+        lora_strength: Cinemagraph LoRA strength note (fixed at load; shown for reference).
+        width: output width (multiple of 64).
+        height: output height (multiple of 64).
 
     Returns:
-        (video_path, used_seed)
+        (video_path, used_seed): the generated .mp4 and the seed actually used.
     """
     if image is None:
-        raise gr.Error("Please provide an input image to animate.")
-    if not prompt or not prompt.strip():
-        raise gr.Error("Please provide a prompt describing the motion.")
-
-    # Ensure the LoRA trigger word is present.
-    if TRIGGER.lower() not in prompt.lower():
-        prompt = f"{TRIGGER}, {prompt.strip()}"
-
-    width, height = _round64(width), _round64(height)
+        raise gr.Error("Please upload a still image to animate.")
+    if not (prompt or "").strip():
+        raise gr.Error("Describe what should move (e.g. 'only the neon sign flickers').")
     used_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-
-    # Normalize the input image to a local temp file path (RGB jpeg).
-    if isinstance(image, str):
-        image_path = image
-    else:
-        image_path = tempfile.mktemp(suffix=".png")
-        Image.fromarray(np.asarray(image)).convert("RGB").save(image_path)
-
-    progress(0.05, desc="encoding prompt (Gemma Space)…")
-    embeddings = fetch_embeddings(prompt, negative_prompt, enhance_prompt, used_seed)
-    progress(0.15, desc="generating cinemagraph…")
-    output_path = _generate_gpu(embeddings, image_path, prompt, negative_prompt, duration,
-                                used_seed, num_inference_steps, video_cfg_scale, width, height)
+    full_prompt = _build_prompt(prompt)
+    if TRIGGER.lower() not in full_prompt.lower():
+        full_prompt = f"{TRIGGER}, {full_prompt}"
+    if "seamless natural loop" not in full_prompt.lower():
+        full_prompt = f"{full_prompt}, seamless natural loop"
+    progress(0.05, desc="encoding prompts (Gemma Space)…")
+    embeddings = fetch_embeddings(full_prompt, negative_prompt, used_seed)
+    output_path = _generate_gpu(
+        embeddings, image, full_prompt, negative_prompt, duration, used_seed,
+        num_inference_steps, video_cfg_scale, lora_strength, width, height)
     return output_path, used_seed
 
 
 CSS = """
-#col-container { max-width: 1100px; margin: 0 auto; }
+#col-container { max-width: 1200px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
-EX_G = ("CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the man, "
-        "face, hair, clothing, beach, sky, and background remain completely frozen, only the "
-        "beach reflection inside his sunglasses moves, reflected time-lapse of ocean waves roll "
-        "and shimmer in the lenses, everything outside the glasses stays still, seamless natural loop")
-EX_J = ("CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the man and "
-        "cow remain completely frozen, only the clouds in the sky move in fast time-lapse, clouds "
-        "drift and roll across the sky, grass and foreground remain still, seamless natural loop.")
-EX_T = ("CINEMAGRAPH_MOTION, tripod locked-off static camera, zero camera movement, the woman is "
-        "frozen, her face, eyes, hair, clothing, seat, and airplane interior remain completely "
-        "frozen, only the illustrated tear drops move downward along her cheeks like a cutout "
-        "collage animation, seamless natural loop.")
-
-with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="LTX-2.3 Cinemagraph") as demo:
+EX_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "examples")
+EXAMPLES = [
+    [os.path.join(EX_DIR, "Glasses.jpeg"),
+     "the man, face, hair, clothing, beach, sky, and background remain completely frozen, only the beach reflection inside his sunglasses moves, reflected time-lapse of ocean waves roll and shimmer in the lenses, everything outside the glasses stays still"],
+    [os.path.join(EX_DIR, "Jump.jpeg"),
+     "the man and cow remain completely frozen, only the clouds in the sky move in fast time-lapse, clouds drift and roll across the sky, grass and foreground remain still"],
+    [os.path.join(EX_DIR, "Motel.jpeg"),
+     "only the neon sign flickers, the starburst, Desert, MOTEL, and NO VACANCY neon tubes subtly pulse and flicker like a real vintage neon sign, everything else stays perfectly still"],
+    [os.path.join(EX_DIR, "Tears.jpeg"),
+     "the woman is frozen, her face, eyes, hair, clothing, seat, and airplane interior remain completely frozen, only the illustrated tear drops move downward along her cheeks like a cutout collage animation"],
+]
+
+with gr.Blocks(title="LTX-2.3 Cinemagraph LoRA", theme=gr.themes.Citrus(), css=CSS) as demo:
     with gr.Column(elem_id="col-container"):
         gr.Markdown(
             "# 🎞️ LTX-2.3 Cinemagraph\n"
-            "Turn a **still image** into a looping **cinemagraph** — selective motion "
-            "(water, light, reflections, clouds) while the rest of the scene stays frozen. "
-            "Powered by the [`LTX-2.3-22b-LoRA-Cinemagraph`](https://huggingface.co/Lightricks/LTX-2.3-22b-LoRA-Cinemagraph) "
-            "LoRA on LTX-2.3-22B. Text encoding runs on a separate Gemma encoder Space.\n\n"
-            "💡 Describe **what moves** and **what stays still**. The `CINEMAGRAPH_MOTION` "
-            "trigger word is added automatically."
+            "Turn a **still image** into a looping **cinemagraph** — only the element you "
+            "describe moves (water, reflections, neon, clouds, rain) while the rest of the "
+            "frame stays frozen. Built on [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) "
+            "with the [Cinemagraph LoRA](https://huggingface.co/Lightricks/LTX-2.3-22b-LoRA-Cinemagraph). "
+            "Text encoding is offloaded to a remote Gemma encoder Space.\n\n"
+            "**Tip:** be explicit — *\"only the [element] moves; everything else frozen.\"* "
+            "The `CINEMAGRAPH_MOTION` trigger and static-camera framing are added for you."
         )
         with gr.Row():
             with gr.Column():
-                image = gr.Image(label="Input image", type="filepath")
-                prompt = gr.Textbox(label="Prompt", lines=3,
-                                    placeholder="only the neon sign flickers, everything else stays perfectly still, seamless natural loop")
-                btn = gr.Button("Generate cinemagraph", variant="primary")
+                image = gr.Image(label="Still image", type="filepath")
+                prompt = gr.Textbox(
+                    label="What should move?", lines=3,
+                    placeholder="only the ocean waves reflected in his sunglasses shimmer; everything else stays frozen",
+                )
+                run = gr.Button("Animate", variant="primary")
                 with gr.Accordion("Advanced settings", open=False):
                     negative_prompt = gr.Textbox(label="Negative prompt", value=DEFAULT_NEGATIVE, lines=2)
                     duration = gr.Slider(1, 8, value=4, step=0.5, label="Duration (s)")
                     with gr.Row():
                         seed = gr.Number(label="Seed", value=42, precision=0)
-                        randomize_seed = gr.Checkbox(label="Randomize seed", value=False)
+                        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
                     with gr.Row():
                         num_inference_steps = gr.Slider(10, 50, value=30, step=1, label="Steps")
-                        video_cfg_scale = gr.Slider(1, 8, value=4.0, step=0.1, label="CFG scale")
+                        video_cfg_scale = gr.Slider(1, 8, value=4.0, step=0.1, label="Guidance (CFG)")
+                    lora_strength = gr.Slider(0.5, 3.0, value=DEFAULT_LORA_STRENGTH, step=0.1,
+                                              label="LoRA strength (set at load)")
                     with gr.Row():
-                        width = gr.Slider(320, 1024, value=704, step=64, label="Width")
-                        height = gr.Slider(320, 1024, value=512, step=64, label="Height")
-                    enhance_prompt = gr.Checkbox(label="Enhance prompt (Gemma)", value=True)
+                        width = gr.Slider(384, 1024, value=704, step=64, label="Width")
+                        height = gr.Slider(384, 1024, value=512, step=64, label="Height")
             with gr.Column():
                 video = gr.Video(label="Cinemagraph", autoplay=True, loop=True)
                 used_seed = gr.Number(label="Used seed", precision=0)
 
+        inputs = [image, prompt, negative_prompt, duration, seed, randomize_seed,
+                  num_inference_steps, video_cfg_scale, lora_strength, width, height]
+        run.click(generate, inputs, [video, used_seed], api_name="generate")
+
         gr.Examples(
-            examples=[
-                ["examples/Glasses.jpeg", EX_G],
-                ["examples/Jump.jpeg", EX_J],
-                ["examples/Tears.jpeg", EX_T],
-            ],
+            examples=EXAMPLES,
             inputs=[image, prompt],
             outputs=[video, used_seed],
             fn=generate,
@@ -412,13 +415,5 @@ with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="LTX-2.3 Cinemagraph") a
             cache_mode="lazy",
         )
 
-    btn.click(
-        generate,
-        [image, prompt, negative_prompt, duration, seed, randomize_seed,
-         num_inference_steps, video_cfg_scale, width, height, enhance_prompt],
-        [video, used_seed],
-        api_name="generate",
-    )
-
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    demo.launch(mcp_server=True, show_error=True)