Add 'Train with your agent' hand-off button

app.py

@@ -100,6 +100,23 @@ button.primary {box-shadow:0 6px 22px rgba(255,140,50,0.28);}
 /* file drop zone: a single input-shade panel (kill the lighter inner button) + readable text */
 #ds-upload {background:rgba(255,255,255,0.04) !important;}
 #ds-upload * {background-color:transparent !important; color:#cfcabf !important;}
+/* agent hand-off modal — CSS overlay on a gr.Column, shown/hidden via its `visible` toggle.
+   `visible=False` sets display:none (overrides this id's display:flex), so it stays hidden. */
+#agent-modal {position:fixed; inset:0; z-index:1000; display:flex; align-items:center; justify-content:center;
+              background:rgba(0,0,0,0.55) !important; backdrop-filter:blur(4px); border:none !important; padding:18px;}
+/* our id selector (specificity 100) would otherwise beat gradio's `.hide` (10) and keep the
+   modal on screen after Close — this restores the hide when `visible=False` adds `.hide`. */
+#agent-modal.hide {display:none !important;}
+#agent-modal-card {max-width:940px; width:94%; max-height:88vh; overflow:auto;
+                   background:#1e2024 !important; border:1px solid rgba(255,255,255,0.18) !important;
+                   border-radius:16px !important; padding:22px 24px !important;
+                   box-shadow:0 24px 80px rgba(0,0,0,0.7), 0 0 0 1px rgba(255,255,255,0.05);}
+#agent-open-btn {white-space:nowrap;}
+/* tighten the modal heading→text gap and make inline `code` readable on the dark card */
+#agent-modal-card h1, #agent-modal-card h2, #agent-modal-card h3 {margin:0 0 4px !important;}
+#agent-modal-card p {margin:.15rem 0 !important;}
+#agent-modal-card code {background:rgba(255,255,255,0.12) !important; color:#f2efe9 !important;
+                        padding:1px 6px; border-radius:5px;}
 footer {visibility:hidden;}
 """
 
@@ -169,6 +186,111 @@ PROFILES = {
 }
 
 
+def _fmt_lr(v: float) -> str:
+    """2e-4 / 1e-4 style (matches the LR field's helper text)."""
+    return f"{v:.0e}".replace("e-0", "e-").replace("e+0", "e+")
+
+
+def _build_agent_playbook() -> str:
+    """Assemble the copy-paste agent playbook from the SAME constants the UI uses
+    (jobs.MODES, PROFILES, MODE_HELP, FLAVOR_GUIDE, RESOLUTION_PRESETS) so its tips and
+    recipe tables never drift from the live app. Fully generic: no user data, no token —
+    the agent reads HF_TOKEN from its own environment."""
+    mode_rows = "\n".join(
+        f"| {m} | {_fmt_lr(jobs.MODES[m]['recommended']['learning_rate'])} | "
+        f"{jobs.MODES[m]['recommended']['steps']} |"
+        for m in MODE_KEYS
+    )
+
+    def _prow(name: str, p: dict) -> str:
+        return (f"| {name} | {p['quantization']} | {p['optimizer_type']} | "
+                f"{'on' if p['te_8bit'] else 'off'} | {p['rank']} | {p['alpha']} | {p['flavor']} |")
+
+    profile_rows = "\n".join([
+        _prow(PROFILE_QUALITY, PROFILES[PROFILE_QUALITY]),
+        _prow(PROFILE_LOWVRAM, PROFILES[PROFILE_LOWVRAM]),
+        f"| {PROFILE_CUSTOM} | (you choose) | (you choose) | (you choose) | 32 | 32 | (you choose) |",
+    ])
+    presets = " · ".join(f"`{v}` ({label.split('·')[-1].strip()})" for label, v in RESOLUTION_PRESETS)
+
+    return f"""# Train an LTX-2.3 LoRA for me (ltx-community/ltx2-lora-trainer)
+
+You're acting as the trainer Space's UI, but conversational. Walk me through the 4
+steps below **one at a time**. After I answer, apply the suggested defaults from the
+tables (I can override any of them), then submit the job *exactly the way the Space
+does* (Step 4). Confirm my final choices before launching.
+
+## Step 1 — Dataset
+{MODE_HELP}
+
+- **Dataset source**: a Hub dataset repo (trainer-format `dataset.json`: `media_path`
+  + `caption` [+ `reference_video` for IC-LoRA]), OR a local folder of clips I point you to.
+- **Captioning**: drop a `clip.txt` next to each clip for a per-clip caption; otherwise a
+  shared caption is used. LTX-2.3 likes long, detailed, *chronological* captions (~200 words:
+  motion, camera, lighting, audio). A **trigger word** is prepended to every caption so I can
+  invoke the LoRA at inference. For IC-LoRA, every target `X.mp4` needs a paired `X_reference.mp4`.
+
+**Apply on mode selection (editable):**
+| mode | learning_rate | steps |
+|---|---|---|
+{mode_rows}
+
+## Step 2 — Training  (defaults auto-applied from mode + profile — tweak freely)
+- **Resolution** `WxHxF` (default `768x512x49`). Rule: W,H divisible by 32; `F % 8 == 1`.
+  Presets: {presets}.
+- **Rank/alpha**: keep alpha = rank, range 8–128. **LR/steps** come from the mode table above.
+- **Advanced**: batch size 1 (required for multi-resolution datasets), grad accumulation 1,
+  validate every 250 steps (inference uses 30 steps).
+
+**Apply on performance-profile selection (editable):**
+| profile | quantization | optimizer | TE 8-bit | rank | alpha | GPU flavor |
+|---|---|---|---|---|---|---|
+{profile_rows}
+
+## Step 3 — Launch
+- **Run name**, whether to **push** the LoRA to my Hub, and the **hub model id**.
+- **GPU flavor** (the profile suggests one; change freely):
+
+{FLAVOR_GUIDE}
+- **Timeout** (default `6h`). The first run spends ~minutes downloading the model.
+
+## Step 4 — Submit & monitor (use the Space's own backend)
+Use MY Hugging Face token from the environment (`hf auth login` or `HF_TOKEN`) — never
+hard-code it. Fill `params` with my resolved answers from Steps 1–3, then run:
+
+    # pip install "huggingface_hub>=1.5" pyyaml hf_xet
+    import os, sys, time
+    from huggingface_hub import snapshot_download
+    sys.path.insert(0, snapshot_download("ltx-community/ltx2-lora-trainer", repo_type="space"))
+    import jobs
+
+    params = {{
+        "mode": "<mode from Step 1>",
+        "dataset_repo": "<hub dataset, or '' if passing local files below>",
+        "run_name": "ltx2-lora",
+        "resolution": "768x512x49",
+        "rank": 32, "alpha": 32,                       # from profile table
+        "learning_rate": 2e-4, "steps": 3000,          # from mode table
+        "batch_size": 1, "gradient_accumulation_steps": 1, "validation_interval": 250,
+        "quantization": None, "optimizer_type": "adamw", "load_text_encoder_in_8bit": False,
+        "push_to_hub": True, "hub_model_id": "USERNAME/my-lora",
+        "caption_all": "", "trigger_word": "", "seed": 42,
+        "hf_token": os.environ["HF_TOKEN"],
+    }}
+    # Hub dataset -> [] ; local clips -> ["clip1.mp4", "clip1_reference.mp4", ...]
+    res = jobs.submit(params, [], flavor="rtx-pro-6000", timeout="6h")
+    job_id = res["job_id"]; print("Submitted:", res["url"] or job_id)
+    while True:
+        st = jobs.job_status(job_id, params["hf_token"]); print("status:", st)
+        if st.upper() in {{"COMPLETED", "ERROR", "CANCELLED", "FAILED"}}: break
+        time.sleep(30)
+    print(jobs.job_logs(job_id, params["hf_token"])[-4000:])
+"""
+
+
+AGENT_PLAYBOOK = _build_agent_playbook()
+
+
 def _apply_profile(profile: str, rank_dirty: bool, alpha_dirty: bool, flavor_dirty: bool):
     """Cascade a profile to (quantization, optimizer, te_8bit, rank, alpha, manual-group visibility,
     flavor). rank/alpha/flavor respect dirty flags (preserve manual edits); Custom reveals manual
@@ -269,10 +391,31 @@ with gr.Blocks(title="LTX-2.3 LoRA Trainer") as demo:
             "Train a LoRA / IC-LoRA on your own videos — runs on **HF Jobs**, pushed to your Hub.",
             elem_id="hero",
         )
-        gr.LoginButton(scale=0, min_width=200)
+        with gr.Column(scale=0, min_width=210):
+            gr.LoginButton()
+            agent_open_btn = gr.Button("🤖 Train with your agent", variant="secondary",
+                                       size="sm", elem_id="agent-open-btn")
 
     banner = gr.Markdown(elem_id="banner")
 
+    # ── agent hand-off modal ──────────────────────────────────────────────────
+    # CSS overlay (see #agent-modal) toggled by the hero button. Uses a Column, not a
+    # Group: a Group renders its elem_id on two nested divs and won't re-hide via
+    # `visible=False`, whereas a Column toggles cleanly. The snippet is a fully generic
+    # playbook built from the same constants the UI uses — no user data, no token
+    # (the agent reads HF_TOKEN from its own environment).
+    with gr.Column(visible=False, elem_id="agent-modal") as agent_modal:
+        with gr.Column(elem_id="agent-modal-card"):
+            gr.Markdown(
+                "### 🤖 Train with your agent\n"
+                "Copy the prompt below into your coding agent. It walks you through the same steps "
+                "as this UI, then launches training on **HF Jobs** under your account with your own "
+                "Hugging Face token (`hf auth login`) — no token or data is embedded here."
+            )
+            gr.Code(value=AGENT_PLAYBOOK, language="markdown", lines=20, max_lines=22,
+                    wrap_lines=False, interactive=False, show_label=False, elem_id="agent-snippet")
+            agent_close_btn = gr.Button("Close", variant="secondary")
+
     with gr.Tabs():
         # ----------------------------------------------------------------- 1 · Dataset
         with gr.Tab("1 · Dataset"):
@@ -410,6 +553,10 @@ with gr.Blocks(title="LTX-2.3 LoRA Trainer") as demo:
     ).then(_extract_id, inputs=joblink, outputs=job_id)
     refresh_btn.click(refresh, inputs=[job_id], outputs=[mon_status, mon_logs])
 
+    # agent hand-off modal open/close (no inputs → emits the same generic playbook every time)
+    agent_open_btn.click(lambda: gr.update(visible=True), outputs=agent_modal)
+    agent_close_btn.click(lambda: gr.update(visible=False), outputs=agent_modal)
+
 
 if __name__ == "__main__":
     demo.queue(default_concurrency_limit=2).launch(theme=THEME, css=CSS)