feat(app): generate handler — async streaming, status banner, video output

app.py

@@ -93,7 +93,14 @@ def build_app() -> gr.Blocks:
                 _render_sidebar()
             with gr.Column(scale=4):
                 handles = _render_mode_panels()
-        # Generate-handler wiring deferred to Task 23.
+
+        for name, h in handles.items():
+            inputs = _collect_inputs_for_mode(name, h)
+            h["generate_btn"].click(
+                fn=_make_handler(name, h),
+                inputs=inputs,
+                outputs=[h["status"], h["video_out"]],
+            )
     return app
 
 
@@ -161,6 +168,152 @@ def _render_one_mode(name: str) -> dict:
     return handles
 
 
+import time
+from typing import Any
+
+import workflow as wf_module
+import backend as backend_module
+
+_BACKEND: backend_module.ComfyUILibraryBackend | None = None
+
+
+def _get_backend() -> backend_module.ComfyUILibraryBackend:
+    global _BACKEND
+    if _BACKEND is None:
+        _BACKEND = backend_module.ComfyUILibraryBackend()
+    return _BACKEND
+
+
+PRESET_DURATION = {"Fast": 60, "Balanced": 120, "Quality": 300}
+
+
+async def _on_generate(mode_name: str, **inputs: Any):
+    """Generate handler — async generator yielding (status_html, video_path)."""
+    mode = modes.MODE_REGISTRY[mode_name]
+
+    # Translate UI inputs into the parameterize_fn input dict.
+    params: dict[str, Any] = {
+        "prompt": inputs.get("prompt", ""),
+        "negative_prompt": inputs.get("negative_prompt", ""),
+        "preset": inputs.get("preset", "Balanced").lower(),
+        "width": int(inputs.get("width", 512)),
+        "height": int(inputs.get("height", 768)),
+        "frames": int(inputs.get("frames", 81)),
+        "fps": int(inputs.get("fps", 24)),
+        "seed": int(inputs.get("seed", 42)),
+    }
+    for k in ("image", "audio", "first_frame", "last_frame", "input_video",
+              "camera_lora", "camera_strength",
+              "detailer_on", "detailer_strength",
+              "ic_lora", "ic_strength", "pose_on", "audio_cfg", "image_strength"):
+        if k in inputs:
+            params[k] = inputs[k]
+
+    patches = mode.parameterize_fn(params)
+    workflow = wf_module.load_template(mode_name)
+    for patch in patches:
+        wf_module.set_input(workflow, *patch)
+    wf_module.validate(workflow)
+
+    backend = _get_backend()
+    duration = PRESET_DURATION.get(inputs.get("preset", "Balanced"), 120)
+
+    started = time.time()
+    async for event in backend.submit(mode_name, workflow, gpu_duration=duration):
+        elapsed = time.time() - started
+        if isinstance(event, backend_module.DownloadEvent):
+            status = ui.render_status(
+                stage_index=0,
+                stage_label=f"Downloading {event.filename}",
+                step=int(event.mb_done),
+                total_steps=int(max(event.mb_total, 1)),
+                elapsed_s=elapsed, eta_s=0,
+            )
+            yield status, gr.update()
+        elif isinstance(event, backend_module.ProgressEvent):
+            stage = (
+                mode.stage_map[event.stage]
+                if event.stage < len(mode.stage_map)
+                else mode.stage_map[-1]
+            )
+            eta = (elapsed / max(event.step, 1)) * (event.total_steps - event.step)
+            status = ui.render_status(
+                stage_index=event.stage + 1,
+                stage_label=stage.label,
+                step=event.step,
+                total_steps=event.total_steps,
+                elapsed_s=elapsed, eta_s=eta,
+            )
+            yield status, gr.update()
+        elif isinstance(event, backend_module.OutputEvent):
+            yield ui._render_idle(), event.video_path
+        elif isinstance(event, backend_module.ErrorEvent):
+            error_html = (
+                f'<div class="status-card status-error">'
+                f'  <div class="status-row"><span class="status-stage">Error · {event.category}</span></div>'
+                f'  <div>{event.message}</div>'
+                f'</div>'
+            )
+            yield error_html, gr.update()
+
+
+def _input_keys_for_mode(mode_name: str, h: dict) -> list[str]:
+    base = ["prompt", "preset", "width", "height", "frames", "fps", "seed"]
+    if mode_name == "i2v":
+        base.append("image")
+    elif mode_name == "a2v":
+        base.append("audio")
+    elif mode_name == "lipsync":
+        base.extend(["image", "audio"])
+    elif mode_name == "keyframe":
+        base.extend(["first_frame", "last_frame"])
+    elif mode_name == "style":
+        base.append("input_video")
+    base.append("negative_prompt")
+    base.extend(["camera_lora", "camera_strength", "detailer_on", "detailer_strength"])
+    if h["lora"].ic_lora is not None:
+        base.extend(["ic_lora", "ic_strength"])
+    if h["lora"].pose_on is not None:
+        base.append("pose_on")
+    return base
+
+
+def _collect_inputs_for_mode(mode_name: str, h: dict) -> list:
+    """Gather the gr.Component handles to pass into _on_generate."""
+    base = [h["prompt"], h["preset"], h["width"], h["height"], h["frames"], h["fps"], h["seed"]]
+    if mode_name == "i2v":
+        base.append(h["image"])
+    elif mode_name == "a2v":
+        base.append(h["audio"])
+    elif mode_name == "lipsync":
+        base.extend([h["image"], h["audio"]])
+    elif mode_name == "keyframe":
+        base.extend([h["first_frame"], h["last_frame"]])
+    elif mode_name == "style":
+        base.append(h["input_video"])
+    base.append(h["negative_prompt"])
+    base.extend([
+        h["lora"].camera_lora, h["lora"].camera_strength,
+        h["lora"].detailer_on, h["lora"].detailer_strength,
+    ])
+    if h["lora"].ic_lora is not None:
+        base.extend([h["lora"].ic_lora, h["lora"].ic_strength])
+    if h["lora"].pose_on is not None:
+        base.append(h["lora"].pose_on)
+    return base
+
+
+def _make_handler(mode_name: str, h: dict):
+    keys = _input_keys_for_mode(mode_name, h)
+
+    async def handler(*values):
+        kwargs = dict(zip(keys, values))
+        async for output in _on_generate(mode_name, **kwargs):
+            yield output
+
+    return handler
+
+
 if __name__ == "__main__":
     app = build_app()
     app.launch(server_name="0.0.0.0", server_port=7860)