Update app.py

app.py

@@ -1,131 +1,124 @@
 """
-⚡ TimeLapseForge — JSON to Timelapse Video in One Click
-Main Gradio Application for Hugging Face Spaces.
+⚡ TimeLapseForge v2.0 — Universal API Edition
+Supports 13+ image generation APIs + local models.
 """
 
 import os
 import json
-import tempfile
 import gradio as gr
 import numpy as np
 from PIL import Image
 from typing import List, Optional
 
-# Import our modules
 from prompt_parser import PromptParser, QuickGenerator
 from frame_interpolator import FrameInterpolator
 from video_assembler import VideoAssembler
+from api_providers import (
+    PROVIDERS, PROVIDER_DISPLAY_NAMES,
+    get_models_for_provider, get_provider_info,
+)
 
-# ─── Initialize Modules ─────────────────────────────────────
+# ─── Initialize ──────────────────────────────────────────────
 prompt_parser = PromptParser()
 quick_gen = QuickGenerator()
 interpolator = FrameInterpolator()
 assembler = VideoAssembler()
 
 # ─── Constants ───────────────────────────────────────────────
-MODELS = {
-    "SDXL Turbo (Fast, 512px)": "stabilityai/sdxl-turbo",
-    "SDXL Base (HQ, 1024px)": "stabilityai/stable-diffusion-xl-base-1.0",
-    "SD 1.5 (Lightweight, 512px)": "runwayml/stable-diffusion-v1-5",
+LOCAL_MODELS = {
+    "SDXL Turbo (Fast)": "stabilityai/sdxl-turbo",
+    "SDXL Base (HQ)": "stabilityai/stable-diffusion-xl-base-1.0",
+    "SD 1.5 (Light)": "runwayml/stable-diffusion-v1-5",
 }
 
-# ─── Lazy import image generator (heavy deps) ───────────────
-_image_gen_class = None
+PROVIDER_CHOICES = [p["display_name"] for p in get_provider_info()]
 
-def get_image_generator_class():
-    global _image_gen_class
-    if _image_gen_class is None:
-        from image_generator import ImageGenerator
-        _image_gen_class = ImageGenerator
-    return _image_gen_class
 
-# ─── Core Functions ──────────────────────────────────────────
+# ─── Helper: Get provider key from display name ─────────────
+def display_to_key(display_name):
+    return PROVIDER_DISPLAY_NAMES.get(display_name, "openai")
 
+
+# ─── Dynamic Model List ─────────────────────────────────────
+def update_model_list(provider_display_name):
+    key = display_to_key(provider_display_name)
+    models = get_models_for_provider(key)
+    if models:
+        return gr.update(choices=models, value=models[0])
+    return gr.update(choices=["custom"], value="custom")
+
+
+# ─── Parse Input ─────────────────────────────────────────────
 def parse_input(json_text, quick_text, num_panels, mode):
-    """Parse JSON input or generate from quick text."""
     if json_text and json_text.strip():
         result = prompt_parser.parse(json_text)
         if result["success"]:
             data = result["data"]
             prompts = prompt_parser.extract_prompts(data)
             summary = prompt_parser.get_summary(data)
-            table_data = [
-                [p["panel_id"], p["phase"], p["panel_title"], p["main_prompt"][:100] + "..."]
-                for p in prompts
-            ]
-            return (
-                summary,
-                table_data,
-                json.dumps(data, indent=2),
-                gr.update(visible=True),
-            )
-        else:
-            return (
-                f"❌ JSON Parse Error: {result['error']}\n\nCheck your JSON format.",
-                [],
-                "",
-                gr.update(visible=False),
-            )
+            table = [[p["panel_id"], p["phase"], p["panel_title"],
+                       p["main_prompt"][:100] + "..."] for p in prompts]
+            return summary, table, json.dumps(data, indent=2), gr.update(visible=True)
+        return f"❌ Parse Error: {result['error']}", [], "", gr.update(visible=False)
     elif quick_text and quick_text.strip():
-        data = quick_gen.generate(quick_text, num_panels=int(num_panels), mode=mode)
+        data = quick_gen.generate(quick_text, int(num_panels), mode)
         prompts = prompt_parser.extract_prompts(data)
         summary = prompt_parser.get_summary(data)
-        table_data = [
-            [p["panel_id"], p["phase"], p["panel_title"], p["main_prompt"][:100] + "..."]
-            for p in prompts
-        ]
-        return (
-            summary + "\n\n⚠️ *Generated from quick text. Use GPT JSON for better results.*",
-            table_data,
-            json.dumps(data, indent=2),
-            gr.update(visible=True),
-        )
-    else:
-        return (
-            "⚠️ Please paste JSON or enter a quick text description.",
-            [],
-            "",
-            gr.update(visible=False),
-        )
+        table = [[p["panel_id"], p["phase"], p["panel_title"],
+                   p["main_prompt"][:100] + "..."] for p in prompts]
+        return (summary + "\n\n⚠️ *Quick text — use GPT JSON for better results*",
+                table, json.dumps(data, indent=2), gr.update(visible=True))
+    return "⚠️ Paste JSON or enter quick text.", [], "", gr.update(visible=False)
 
 
+# ─── Generate Panels ─────────────────────────────────────────
 def generate_panels(
-    parsed_json, model_name, strength, base_seed,
-    steps, guidance, ref_image, progress=gr.Progress(),
+    parsed_json, gen_mode, local_model, provider_name, api_key,
+    api_model, custom_base_url, custom_endpoint_url,
+    strength, base_seed, steps, guidance, width, height,
+    ref_image, progress=gr.Progress(),
 ):
-    """Generate all panel images."""
     if not parsed_json:
-        return [], [], "❌ No parsed JSON found. Parse input first."
+        return [], [], "❌ No JSON. Parse input first."
 
     try:
         data = json.loads(parsed_json)
     except json.JSONDecodeError:
-        return [], [], "❌ Invalid parsed JSON."
+        return [], [], "❌ Invalid JSON."
 
     prompts = prompt_parser.extract_prompts(data)
     if not prompts:
-        return [], [], "❌ No panels found in JSON."
+        return [], [], "❌ No panels found."
 
-    model_id = MODELS.get(model_name, "stabilityai/sdxl-turbo")
-    ImageGenerator = get_image_generator_class()
-    gen = ImageGenerator(model_id)
+    from image_generator import ImageGenerator
 
-    progress(0, desc="Loading model...")
+    if gen_mode == "🖥️ Local (Free GPU)":
+        model_id = LOCAL_MODELS.get(local_model, "stabilityai/sdxl-turbo")
+        gen = ImageGenerator(mode="local", local_model_id=model_id)
+    else:
+        pkey = display_to_key(provider_name)
+        if not api_key or not api_key.strip():
+            return [], [], f"❌ API key required for {provider_name}"
+        gen = ImageGenerator(
+            mode="api", provider_name=pkey, api_key=api_key.strip(),
+            api_model=api_model, custom_base_url=custom_base_url,
+            custom_endpoint_url=custom_endpoint_url,
+        )
+
+    progress(0, desc="Starting generation...")
 
-    def progress_cb(current, total):
-        progress(current / total, desc=f"Generating panel {current}/{total}")
+    def cb(current, total):
+        progress(current / total, desc=f"Panel {current}/{total}")
 
     gen_steps = int(steps) if steps and int(steps) > 0 else None
     gen_guidance = float(guidance) if guidance is not None and float(guidance) >= 0 else None
+    w = int(width) if width and int(width) > 0 else None
+    h = int(height) if height and int(height) > 0 else None
 
     images = gen.generate_all_panels(
-        prompts=prompts,
-        strength=float(strength),
-        base_seed=int(base_seed),
-        steps=gen_steps,
-        guidance=gen_guidance,
-        reference_image=ref_image,
-        progress_callback=progress_cb,
+        prompts=prompts, strength=float(strength), base_seed=int(base_seed),
+        steps=gen_steps, guidance=gen_guidance, width=w, height=h,
+        reference_image=ref_image, progress_callback=cb,
     )
 
     gallery_items = []
@@ -133,39 +126,30 @@ def generate_panels(
         label = prompts[i]["panel_title"] if i < len(prompts) else f"Panel {i+1}"
         gallery_items.append((img, label))
 
-    status = f"✅ Generated {len(images)} panels successfully!"
-    return gallery_items, images, status
+    return gallery_items, images, f"✅ Generated {len(images)} panels!"
 
 
+# ─── Interpolate & Assemble ──────────────────────────────────
 def interpolate_and_assemble(
     images_state, parsed_json, interp_multiplier, interp_method,
     fps, hold_seconds, add_labels, add_progress_bar, add_bookend,
     music_file, export_gif, progress=gr.Progress(),
 ):
-    """Interpolate frames and assemble video."""
     if not images_state:
-        return None, None, None, "❌ No images. Generate panels first."
+        return None, None, None, "❌ No images. Generate first."
 
     images = images_state
     interp_multiplier = int(interp_multiplier)
 
-    # Step 1: Interpolate
-    progress(0.1, desc="Interpolating frames...")
+    progress(0.1, desc="Interpolating...")
     if interp_multiplier > 1:
-        def interp_cb(current, total):
-            p = 0.1 + (current / total) * 0.3
-            progress(p, desc=f"Interpolating {current}/{total} pairs")
-
-        smooth_frames = interpolator.interpolate_sequence(
-            images,
-            multiplier=interp_multiplier,
-            method=interp_method,
-            progress_callback=interp_cb,
-        )
+        def icb(c, t):
+            progress(0.1 + (c/t)*0.3, desc=f"Interpolating {c}/{t}")
+        smooth = interpolator.interpolate_sequence(
+            images, interp_multiplier, interp_method, icb)
     else:
-        smooth_frames = list(images)
+        smooth = list(images)
 
-    # Step 2: Extract labels
     labels = None
     if add_labels and parsed_json:
         try:
@@ -173,57 +157,48 @@ def interpolate_and_assemble(
             prompts = prompt_parser.extract_prompts(data)
             if interp_multiplier > 1:
                 labels = []
-                for i, p in enumerate(prompts):
+                for p in prompts:
                     labels.append(p.get("timestamp_label", ""))
                     labels.extend([""] * interp_multiplier)
-                labels = labels[:len(smooth_frames)]
+                labels = labels[:len(smooth)]
             else:
                 labels = [p.get("timestamp_label", "") for p in prompts]
         except Exception:
-            labels = None
+            pass
 
-    # Step 3: Assemble video
     progress(0.5, desc="Assembling video...")
-    adj_hold = float(hold_seconds)
-    if interp_multiplier > 1:
-        adj_hold = adj_hold / max(interp_multiplier, 1)
+    adj_hold = float(hold_seconds) / max(interp_multiplier, 1) if interp_multiplier > 1 else float(hold_seconds)
 
     video_path = assembler.create_video(
-        images=smooth_frames,
-        fps=int(fps),
-        hold_seconds=adj_hold,
-        add_labels=add_labels,
-        labels=labels,
-        add_progress=add_progress_bar,
-        add_bookend_labels=add_bookend,
+        smooth, fps=int(fps), hold_seconds=adj_hold,
+        add_labels=add_labels, labels=labels,
+        add_progress=add_progress_bar, add_bookend_labels=add_bookend,
     )
 
-    # Step 4: Add audio
     if music_file:
         progress(0.8, desc="Adding audio...")
         video_path = assembler.add_audio_to_video(video_path, music_file)
 
-    # Step 5: Comparison image
-    progress(0.9, desc="Creating comparison...")
+    progress(0.9, desc="Comparison...")
     comparison = assembler.create_comparison_image(images[0], images[-1])
 
-    # Step 6: GIF
     gif_path = None
     if export_gif:
-        progress(0.95, desc="Creating GIF...")
-        gif_path = assembler.create_gif(images, duration_per_frame=400)
+        progress(0.95, desc="GIF...")
+        gif_path = assembler.create_gif(images)
 
-    progress(1.0, desc="Done!")
-    status = f"✅ Video created! {len(smooth_frames)} frames at {int(fps)}fps"
-    return video_path, comparison, gif_path, status
+    return video_path, comparison, gif_path, f"✅ Done! {len(smooth)} frames at {int(fps)}fps"
 
 
+# ─── Regenerate Single ───────────────────────────────────────
 def regenerate_single(
-    panel_num, parsed_json, images_state, model_name, strength, base_seed,
+    panel_num, parsed_json, images_state,
+    gen_mode, local_model, provider_name, api_key,
+    api_model, custom_base_url, custom_endpoint_url,
+    strength, base_seed,
 ):
-    """Regenerate a single panel."""
     if not images_state or not parsed_json:
-        return images_state, [], "❌ No images or JSON found."
+        return images_state, [], "❌ No data."
 
     try:
         data = json.loads(parsed_json)
@@ -233,172 +208,239 @@ def regenerate_single(
 
     idx = int(panel_num) - 1
     if idx < 0 or idx >= len(images_state):
-        return images_state, [], f"❌ Invalid panel number. Must be 1-{len(images_state)}."
+        return images_state, [], f"❌ Panel must be 1-{len(images_state)}"
 
-    model_id = MODELS.get(model_name, "stabilityai/sdxl-turbo")
-    ImageGenerator = get_image_generator_class()
-    gen = ImageGenerator(model_id)
+    from image_generator import ImageGenerator
+
+    if gen_mode == "🖥️ Local (Free GPU)":
+        model_id = LOCAL_MODELS.get(local_model, "stabilityai/sdxl-turbo")
+        gen = ImageGenerator(mode="local", local_model_id=model_id)
+    else:
+        pkey = display_to_key(provider_name)
+        gen = ImageGenerator(
+            mode="api", provider_name=pkey, api_key=api_key.strip(),
+            api_model=api_model, custom_base_url=custom_base_url,
+            custom_endpoint_url=custom_endpoint_url,
+        )
 
     _, updated = gen.regenerate_single_panel(
-        idx, prompts, images_state, float(strength), int(base_seed)
-    )
+        idx, prompts, images_state, float(strength), int(base_seed))
 
-    gallery_items = [(img, f"Panel {i+1}") for i, img in enumerate(updated)]
-    return updated, gallery_items, f"✅ Panel {int(panel_num)} regenerated!"
+    gallery = [(img, f"Panel {i+1}") for i, img in enumerate(updated)]
+    return updated, gallery, f"✅ Panel {int(panel_num)} regenerated!"
 
 
-# ─── Gradio UI ───────────────────────────────────────────────
+# ═══════════════════════════════════════════
+# GRADIO UI
+# ════════════════════��══════════════════════
 
-HEADER_MD = """
-# ⚡ TimeLapseForge
-### JSON to Timelapse Video — One Click Pipeline
+HEADER = """
+# ⚡ TimeLapseForge v2.0 — Universal API Edition
+### Supports **13+ AI Image APIs** — Enter YOUR API key, select model, generate!
 
-**Workflow:** Paste GPT JSON → Generate Consistent Panels → Smooth Interpolation → Export Video
+**OpenAI** · **Stability AI** · **Replicate** · **Together AI** · **Fal.ai** · **Google Gemini**
+· **HuggingFace** · **xAI Grok** · **Fireworks** · **Ideogram** · **Leonardo** · **Custom API** · **Local GPU**
 """
 
+API_HELP = """
+### 🔑 Where to Get API Keys
+
+| Provider | Get Key | Free Tier? |
+|---|---|---|
+| OpenAI | [platform.openai.com](https://platform.openai.com/api-keys) | Pay-per-use |
+| Stability AI | [platform.stability.ai](https://platform.stability.ai/account/keys) | 25 free credits |
+| Replicate | [replicate.com](https://replicate.com/account/api-tokens) | Free tier |
+| Together AI | [api.together.xyz](https://api.together.xyz/settings/api-keys) | $5 free |
+| Fal.ai | [fal.ai/dashboard](https://fal.ai/dashboard/keys) | $10 free |
+| Google Gemini | [aistudio.google.com](https://aistudio.google.com/apikey) | Free! |
+| HuggingFace | [huggingface.co](https://huggingface.co/settings/tokens) | Free! |
+| xAI Grok | [console.x.ai](https://console.x.ai/team/default/api-keys) | $25 free/mo |
+| Fireworks | [fireworks.ai](https://fireworks.ai/account/api-keys) | $1 free |
+| Ideogram | [ideogram.ai](https://ideogram.ai/manage-api) | Pay-per-use |
+| Leonardo | [leonardo.ai](https://app.leonardo.ai/api-access) | 150 free/day |
+"""
+
+
 with gr.Blocks(
-    title="⚡ TimeLapseForge",
+    title="⚡ TimeLapseForge v2.0",
     theme=gr.themes.Soft(primary_hue="emerald", secondary_hue="blue"),
 ) as app:
 
-    # Shared State
     images_state = gr.State(value=[])
     parsed_json_state = gr.State(value="")
 
-    gr.Markdown(HEADER_MD)
+    gr.Markdown(HEADER)
 
     with gr.Tabs():
 
-        # ── TAB 1: INPUT ──
+        # ════════════════════════════════════════
+        # TAB 1: INPUT
+        # ════════════════════════════════════════
         with gr.Tab("📥 Input & Parse"):
             with gr.Row():
                 with gr.Column(scale=2):
                     json_input = gr.Textbox(
-                        label="📋 Paste GPT JSON Output",
-                        placeholder='Paste the complete JSON here...\n{\n  "project_metadata": {...},\n  "panels": [...]\n}',
+                        label="📋 Paste GPT JSON",
+                        placeholder='{\n  "project_metadata": {...},\n  "panels": [...]\n}',
                         lines=15,
                     )
                 with gr.Column(scale=1):
                     gr.Markdown("**— OR — Quick Text:**")
                     quick_text = gr.Textbox(
-                        label="⚡ Quick Text Command",
-                        placeholder="e.g., Restore a rusty 1969 Camaro SS",
+                        label="⚡ Quick Command",
+                        placeholder="Restore a rusty 1969 Camaro SS",
                         lines=3,
                     )
-                    with gr.Row():
-                        quick_panels = gr.Slider(
-                            8, 40, value=20, step=1, label="Panels"
-                        )
-                        quick_mode = gr.Dropdown(
-                            ["restoration", "creation"],
-                            value="restoration",
-                            label="Mode",
-                        )
+                    quick_panels = gr.Slider(8, 40, value=20, step=1, label="Panels")
+                    quick_mode = gr.Dropdown(
+                        ["restoration", "creation"], value="restoration", label="Mode")
 
             parse_btn = gr.Button("🔍 Parse & Preview", variant="primary", size="lg")
             parse_status = gr.Markdown("")
             prompt_table = gr.Dataframe(
                 headers=["#", "Phase", "Title", "Prompt Preview"],
-                label="📊 Extracted Panels",
-                visible=False,
-                wrap=True,
-            )
+                label="📊 Panels", visible=False, wrap=True)
 
-        # ── TAB 2: GENERATE ──
+        # ════════════════════════════════════════
+        # TAB 2: GENERATE
+        # ════════════════════════════════════════
         with gr.Tab("🎨 Generate Panels"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    model_choice = gr.Dropdown(
-                        list(MODELS.keys()),
-                        value="SDXL Turbo (Fast, 512px)",
-                        label="🤖 Model",
+                    # --- Generation Mode ---
+                    gen_mode = gr.Radio(
+                        ["🖥️ Local (Free GPU)", "🌐 API (Your Key)"],
+                        value="🌐 API (Your Key)",
+                        label="Generation Mode",
                     )
+
+                    # --- Local Settings ---
+                    with gr.Group(visible=False) as local_group:
+                        gr.Markdown("### 🖥️ Local Model")
+                        local_model = gr.Dropdown(
+                            list(LOCAL_MODELS.keys()),
+                            value="SDXL Turbo (Fast)",
+                            label="Model",
+                        )
+
+                    # --- API Settings ---
+                    with gr.Group(visible=True) as api_group:
+                        gr.Markdown("### 🌐 API Provider")
+                        provider_dropdown = gr.Dropdown(
+                            PROVIDER_CHOICES,
+                            value=PROVIDER_CHOICES[0],
+                            label="Provider",
+                        )
+                        api_key_input = gr.Textbox(
+                            label="🔑 API Key",
+                            placeholder="Paste your API key here...",
+                            type="password",
+                        )
+                        api_model_dropdown = gr.Dropdown(
+                            label="🤖 Model",
+                            choices=get_models_for_provider("openai"),
+                            value="dall-e-3",
+                            allow_custom_value=True,
+                        )
+                        with gr.Accordion("🔧 Custom API Settings", open=False):
+                            custom_base_url = gr.Textbox(
+                                label="Custom Base URL (OpenAI-compatible)",
+                                placeholder="https://your-api.com/v1",
+                            )
+                            custom_endpoint_url = gr.Textbox(
+                                label="Direct Endpoint URL",
+                                placeholder="https://your-api.com/generate",
+                            )
+
+                    # --- Common Settings ---
+                    gr.Markdown("### ⚙️ Generation Settings")
                     strength = gr.Slider(
                         0.15, 0.70, value=0.38, step=0.01,
                         label="🔄 Change Strength",
-                        info="Lower = more consistent between panels",
-                    )
-                    base_seed = gr.Number(value=42, label="🌱 Base Seed", precision=0)
-                    steps = gr.Slider(
-                        0, 50, value=0, step=1,
-                        label="🔢 Steps (0=auto)",
-                    )
-                    guidance = gr.Slider(
-                        -1, 15, value=-1, step=0.5,
-                        label="🎯 Guidance (-1=auto)",
-                    )
-                    ref_image = gr.Image(
-                        label="🖼️ Reference Image (optional)", type="pil",
+                        info="Lower = more consistent",
                     )
+                    base_seed = gr.Number(value=42, label="🌱 Seed", precision=0)
+                    with gr.Row():
+                        steps = gr.Slider(0, 50, value=0, step=1, label="Steps (0=auto)")
+                        guidance = gr.Slider(-1, 15, value=-1, step=0.5, label="CFG (-1=auto)")
+                    with gr.Row():
+                        img_width = gr.Number(value=1024, label="Width", precision=0)
+                        img_height = gr.Number(value=1024, label="Height", precision=0)
+
+                    ref_image = gr.Image(label="🖼️ Reference Image", type="pil")
 
                 with gr.Column(scale=3):
                     generate_btn = gr.Button(
-                        "🚀 Generate All Panels", variant="primary", size="lg"
-                    )
+                        "🚀 Generate All Panels", variant="primary", size="lg")
                     gen_status = gr.Markdown("")
                     gallery = gr.Gallery(
                         label="🖼️ Generated Panels",
-                        columns=5,
-                        rows=3,
-                        height=450,
-                        object_fit="contain",
-                    )
+                        columns=5, rows=3, height=450, object_fit="contain")
 
             with gr.Accordion("🔄 Regenerate Single Panel", open=False):
                 with gr.Row():
-                    regen_panel_num = gr.Number(
-                        value=1, label="Panel Number", precision=0
-                    )
+                    regen_num = gr.Number(value=1, label="Panel #", precision=0)
                     regen_btn = gr.Button("🔄 Regenerate", variant="secondary")
                 regen_status = gr.Markdown("")
 
-        # ── TAB 3: VIDEO ──
+        # ═════════════════════════���══════════════
+        # TAB 3: VIDEO
+        # ════════════════════════════════════════
         with gr.Tab("🎬 Create Video"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### 🎞️ Interpolation")
-                    interp_mult = gr.Slider(
-                        1, 8, value=3, step=1,
-                        label="Frame Multiplier",
-                        info="1=none, 3=smooth, 6=ultra",
-                    )
-                    interp_method = gr.Dropdown(
-                        ["blend", "flow"], value="blend",
-                        label="Method",
-                    )
+                    interp_mult = gr.Slider(1, 8, value=3, step=1, label="Frame Multiplier")
+                    interp_method = gr.Dropdown(["blend", "flow"], value="blend", label="Method")
 
                     gr.Markdown("### 🎬 Video")
                     vid_fps = gr.Slider(12, 60, value=24, step=1, label="FPS")
-                    frame_hold = gr.Slider(
-                        0.3, 5.0, value=1.5, step=0.1,
-                        label="Seconds per Panel",
-                    )
+                    frame_hold = gr.Slider(0.3, 5.0, value=1.5, step=0.1, label="Sec/Panel")
 
                     gr.Markdown("### 🏷️ Overlays")
-                    add_labels = gr.Checkbox(value=True, label="Timestamp labels")
+                    add_labels = gr.Checkbox(value=True, label="Timestamps")
                     add_progress_bar = gr.Checkbox(value=True, label="Progress bar")
-                    add_bookend = gr.Checkbox(value=True, label="BEFORE / AFTER")
+                    add_bookend = gr.Checkbox(value=True, label="BEFORE/AFTER")
 
                     gr.Markdown("### 🎵 Audio")
-                    music_file = gr.Audio(
-                        label="Background Music", type="filepath"
-                    )
-
-                    gr.Markdown("### 📦 Export")
-                    export_gif = gr.Checkbox(value=False, label="Also export GIF")
+                    music_file = gr.Audio(label="Background Music", type="filepath")
+                    export_gif = gr.Checkbox(value=False, label="Export GIF too")
 
                 with gr.Column(scale=2):
                     assemble_btn = gr.Button(
-                        "🎬 Interpolate & Create Video",
-                        variant="primary",
-                        size="lg",
-                    )
+                        "🎬 Create Video", variant="primary", size="lg")
                     vid_status = gr.Markdown("")
-                    video_output = gr.Video(label="🎥 Timelapse Video")
-                    comparison_output = gr.Image(label="📊 Before / After")
-                    gif_output = gr.File(label="📦 GIF Download")
+                    video_output = gr.Video(label="🎥 Timelapse")
+                    comparison_output = gr.Image(label="📊 Before/After")
+                    gif_output = gr.File(label="📦 GIF")
+
+        # ════════════════════════════════════════
+        # TAB 4: API KEYS HELP
+        # ════════════════════════════════════════
+        with gr.Tab("🔑 API Keys Guide"):
+            gr.Markdown(API_HELP)
+
+    # ── Dynamic UI Updates ──
+
+    def toggle_mode(mode):
+        if mode == "🖥️ Local (Free GPU)":
+            return gr.update(visible=True), gr.update(visible=False)
+        return gr.update(visible=False), gr.update(visible=True)
+
+    gen_mode.change(
+        fn=toggle_mode,
+        inputs=[gen_mode],
+        outputs=[local_group, api_group],
+    )
+
+    provider_dropdown.change(
+        fn=update_model_list,
+        inputs=[provider_dropdown],
+        outputs=[api_model_dropdown],
+    )
+
+    # ── Core Event Handlers ──
 
-    # ── Event Handlers ──
     parse_btn.click(
         fn=parse_input,
         inputs=[json_input, quick_text, quick_panels, quick_mode],
@@ -408,8 +450,10 @@ with gr.Blocks(
     generate_btn.click(
         fn=generate_panels,
         inputs=[
-            parsed_json_state, model_choice, strength, base_seed,
-            steps, guidance, ref_image,
+            parsed_json_state, gen_mode, local_model, provider_dropdown,
+            api_key_input, api_model_dropdown, custom_base_url,
+            custom_endpoint_url, strength, base_seed, steps, guidance,
+            img_width, img_height, ref_image,
         ],
         outputs=[gallery, images_state, gen_status],
     )
@@ -417,8 +461,10 @@ with gr.Blocks(
     regen_btn.click(
         fn=regenerate_single,
         inputs=[
-            regen_panel_num, parsed_json_state, images_state,
-            model_choice, strength, base_seed,
+            regen_num, parsed_json_state, images_state,
+            gen_mode, local_model, provider_dropdown, api_key_input,
+            api_model_dropdown, custom_base_url, custom_endpoint_url,
+            strength, base_seed,
         ],
         outputs=[images_state, gallery, regen_status],
     )
@@ -434,6 +480,5 @@ with gr.Blocks(
     )
 
 
-# ─── Launch ──────────────────────────────────────────────────
 if __name__ == "__main__":
     app.launch()