Update streamlit_app.py

streamlit_app.py

@@ -6,36 +6,57 @@ import hashlib
 import traceback
 from glob import glob
 from pathlib import Path
-import logging
+from difflib import SequenceMatcher
+import concurrent.futures
+import json
+
 import yt_dlp
 import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
-from difflib import SequenceMatcher
 
+load_dotenv()
+
+# Optional phi integration (Agent + Gemini wrapper)
 try:
-    import google.generativeai as genai  # type: ignore
-    genai_responses = getattr(genai, "responses", None) or getattr(genai, "Responses", None)
-    upload_file = getattr(genai, "upload_file", None)
-    get_file = getattr(genai, "get_file", None)
+    from phi.agent import Agent
+    from phi.model.google import Gemini
+    from phi.tools.duckduckgo import DuckDuckGo
+    HAS_PHI = True
+except Exception:
+    Agent = Gemini = DuckDuckGo = None
+    HAS_PHI = False
+
+# google.generativeai SDK
+try:
+    import google.generativeai as genai
+    from google.generativeai import upload_file, get_file  # type: ignore
     HAS_GENAI = True
 except Exception:
     genai = None
-    genai_responses = None
-    upload_file = None
-    get_file = None
+    upload_file = get_file = None
     HAS_GENAI = False
 
-load_dotenv()
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("video_ai")
-logger.propagate = False
-
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
-# session defaults
+# ---- Defaults & constants ----
+MODEL_OPTIONS = [
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-lite",
+    "custom",
+]
+
+DEFAULT_MODEL = "gemini-2.0-flash-lite"
+DEFAULT_PROMPT = (
+    "Watch the video and provide a detailed behavioral report focusing on human actions, interactions, posture, movement, and apparent intent. "
+    "Keep language professional. Include a list of observations for notable events."
+)
+
+# ---- Session defaults ----
 st.session_state.setdefault("videos", "")
 st.session_state.setdefault("loop_video", False)
 st.session_state.setdefault("uploaded_file", None)
@@ -47,25 +68,13 @@ st.session_state.setdefault("last_error", "")
 st.session_state.setdefault("file_hash", None)
 st.session_state.setdefault("api_key", os.getenv("GOOGLE_API_KEY", ""))
 st.session_state.setdefault("last_model", "")
+st.session_state.setdefault("upload_progress", {"uploaded": 0, "total": 0})
 st.session_state.setdefault("last_url_value", "")
-st.session_state.setdefault("processing_timeout", 900)
-st.session_state.setdefault("generation_timeout", 300)
-st.session_state.setdefault("preferred_model", "gemini-2.0-flash-lite")
-st.session_state.setdefault("compression_threshold_mb", 200)
-st.session_state.setdefault("model_select", st.session_state.get("preferred_model"))
-st.session_state.setdefault("custom_model", "")
-st.session_state.setdefault("url_input", "")
-st.session_state.setdefault("video_password", "")
-st.session_state.setdefault("analysis_prompt", "")
-
-MODEL_OPTIONS = [
-    "gemini-2.5-flash",
-    "gemini-2.5-flash-lite",
-    "gemini-2.0-flash",
-    "gemini-2.0-flash-lite",
-    "custom",
-]
+st.session_state.setdefault("processing_timeout", 900)  # seconds
+st.session_state.setdefault("generation_timeout", 300)  # seconds
+st.session_state.setdefault("compress_threshold_mb", 200)  # optional compression default
 
+# ---- Helpers ----
 def sanitize_filename(path_str: str):
     name = Path(path_str).name
     return name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
@@ -88,17 +97,13 @@ def convert_video_to_mp4(video_path: str) -> str:
         pass
     return target_path
 
-def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast", bitrate: str = None):
+def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
     try:
-        out = ffmpeg.input(input_path)
-        if bitrate:
-            stream = out.output(target_path, vcodec="libx264", preset=preset, video_bitrate=bitrate)
-        else:
-            stream = out.output(target_path, vcodec="libx264", crf=crf, preset=preset)
-        stream.run(overwrite_output=True, quiet=True)
-        return target_path if os.path.exists(target_path) else input_path
+        ffmpeg.input(input_path).output(
+            target_path, vcodec="libx264", crf=crf, preset=preset
+        ).run(overwrite_output=True, quiet=True)
+        return target_path
     except Exception:
-        logger.exception("Compression failed")
         return input_path
 
 def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
@@ -135,30 +140,109 @@ def configure_genai_if_needed():
     if not key:
         return False
     try:
-        if genai is not None and hasattr(genai, "configure"):
-            genai.configure(api_key=key)
+        genai.configure(api_key=key)
     except Exception:
-        logger.exception("Failed to configure genai")
+        pass
     return True
 
+# ---- Agent management (reuse) ----
+_agent = None
+def maybe_create_agent(model_id: str):
+    global _agent
+    key = get_effective_api_key()
+    if not (HAS_PHI and HAS_GENAI and key):
+        _agent = None
+        return None
+    if _agent and st.session_state.get("last_model") == model_id:
+        return _agent
+    try:
+        genai.configure(api_key=key)
+        _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
+        st.session_state["last_model"] = model_id
+    except Exception:
+        _agent = None
+    return _agent
+
+def clear_all_video_state():
+    st.session_state.pop("uploaded_file", None)
+    st.session_state.pop("processed_file", None)
+    st.session_state["videos"] = ""
+    st.session_state["last_loaded_path"] = ""
+    st.session_state["analysis_out"] = ""
+    st.session_state["last_error"] = ""
+    st.session_state["file_hash"] = None
+    for f in glob(str(DATA_DIR / "*")):
+        try:
+            os.remove(f)
+        except Exception:
+            pass
+
+# Reset when URL changes
+current_url = st.session_state.get("url", "")
+if current_url != st.session_state.get("last_url_value"):
+    clear_all_video_state()
+    st.session_state["last_url_value"] = current_url
+
+# ---- Sidebar UI ----
+st.sidebar.header("Video Input")
+st.sidebar.text_input("Video URL", key="url", placeholder="https://")
+
+settings_exp = st.sidebar.expander("Settings", expanded=False)
+model_choice = settings_exp.selectbox("Select model", options=MODEL_OPTIONS, index=MODEL_OPTIONS.index(DEFAULT_MODEL) if DEFAULT_MODEL in MODEL_OPTIONS else 0)
+if model_choice == "custom":
+    model_input = settings_exp.text_input("Custom model id", value=DEFAULT_MODEL, key="model_input")
+    model_selected = model_input.strip() or DEFAULT_MODEL
+else:
+    st.session_state["model_input"] = model_choice
+    model_selected = model_choice
+
+settings_exp.text_input("Google API Key", key="api_key", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
+analysis_prompt = settings_exp.text_area("Analysis prompt", value=DEFAULT_PROMPT, height=140)
+settings_exp.text_input("Video Password (if needed)", key="video-password", placeholder="password", type="password")
+
+settings_exp.number_input(
+    "Processing timeout (s)", min_value=60, max_value=3600,
+    value=st.session_state.get("processing_timeout", 900), step=30,
+    key="processing_timeout",
+)
+settings_exp.number_input(
+    "Generation timeout (s)", min_value=30, max_value=1800,
+    value=st.session_state.get("generation_timeout", 300), step=10,
+    key="generation_timeout",
+)
+settings_exp.number_input(
+    "Optional compression threshold (MB)", min_value=10, max_value=2000,
+    value=st.session_state.get("compress_threshold_mb", 200), step=10,
+    key="compress_threshold_mb",
+)
+
+key_source = "session" if st.session_state.get("api_key") else ".env" if os.getenv("GOOGLE_API_KEY") else "none"
+settings_exp.caption(f"Using API key from: **{key_source}**")
+if not get_effective_api_key():
+    settings_exp.warning("No Google API key provided; upload/generation disabled.", icon="⚠️")
+
+safety_settings = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
+]
+
+# ---- Upload & processing helpers ----
 def upload_video_sdk(filepath: str):
     key = get_effective_api_key()
     if not key:
         raise RuntimeError("No API key provided")
     if not HAS_GENAI or upload_file is None:
         raise RuntimeError("google.generativeai SDK not available; cannot upload")
-    try:
-        if genai is not None and hasattr(genai, "configure"):
-            genai.configure(api_key=key)
-    except Exception:
-        pass
-    try:
-        return upload_file(filepath)
-    except Exception:
-        logger.exception("Upload failed")
-        raise
-
-def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
+    genai.configure(api_key=key)
+    return upload_file(filepath)
+
+def wait_for_processed(file_obj, timeout: int = None):
+    """
+    Poll get_file until file is no longer PROCESSING.
+    Retries get_file on transient errors with exponential backoff.
+    """
     if timeout is None:
         timeout = st.session_state.get("processing_timeout", 900)
     if not HAS_GENAI or get_file is None:
@@ -177,31 +261,107 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
             time.sleep(backoff)
             backoff = min(backoff * 2, 8.0)
             continue
+
         state = getattr(obj, "state", None)
-        state_name = getattr(state, "name", None) if state else None
-        if progress_callback:
-            elapsed = int(time.time() - start)
-            pct = 50 if state_name == "PROCESSING" else 100
-            try:
-                progress_callback(min(100, pct), elapsed, state_name)
-            except Exception:
-                pass
-        if not state_name or state_name != "PROCESSING":
+        if not state or getattr(state, "name", None) != "PROCESSING":
             return obj
+
         if time.time() - start > timeout:
             raise TimeoutError(f"File processing timed out after {int(time.time() - start)}s")
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
+def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_threshold: float = 0.68):
+    if not prompt or not text:
+        return text
+    a = " ".join(prompt.strip().lower().split())
+    b_full = text.strip()
+    b = " ".join(b_full[:check_len].lower().split())
+    ratio = SequenceMatcher(None, a, b).ratio()
+    if ratio >= ratio_threshold:
+        cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
+        new_text = b_full[cut:].lstrip(" \n:-")
+        if len(new_text) >= 3:
+            return new_text
+    placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
+    low = b_full.strip().lower()
+    for ph in placeholders:
+        if low.startswith(ph):
+            return b_full[len(ph):].lstrip(" \n:-")
+    return text
+
+def compress_video_if_large(local_path: str, threshold_mb: int = 200):
+    try:
+        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
+    except Exception as e:
+        st.session_state["last_error"] = f"Failed to stat file before compression: {e}"
+        return local_path, False
+
+    if file_size_mb <= threshold_mb:
+        return local_path, False
+
+    compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
+    try:
+        result = compress_video(local_path, compressed_path, crf=28, preset="fast")
+        if result and os.path.exists(result):
+            return result, True
+        return local_path, False
+    except Exception as e:
+        st.session_state["last_error"] = f"Video compression failed: {e}\n{traceback.format_exc()}"
+        return local_path, False
+
+# ---- Robust Responses API caller adapted for varying model versions ----
+def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300):
+    key = get_effective_api_key()
+    if not key:
+        raise RuntimeError("No API key provided")
+    if not HAS_GENAI or genai is None:
+        raise RuntimeError("Responses API not available; install google.generativeai SDK.")
+    genai.configure(api_key=key)
+    fname = file_name_or_id(processed)
+    if not fname:
+        raise RuntimeError("Uploaded file missing name/id")
+
+    system_msg = {"role": "system", "content": prompt_text}
+    user_msg = {"role": "user", "content": "Please summarize the attached video."}
+
+    # Some model versions and SDK releases expect messages, some older ones expect input with files.
+    call_variants = [
+        {"messages": [system_msg, user_msg], "files": [{"name": fname}], "safety_settings": safety_settings, "max_output_tokens": max_tokens},
+        {"input": [{"text": prompt_text, "files": [{"name": fname}]}], "safety_settings": safety_settings, "max_output_tokens": max_tokens},
+    ]
+
+    last_exc = None
+    start = time.time()
+    backoff = 1.0
+    while True:
+        for payload in call_variants:
+            try:
+                response = genai.responses.generate(model=model_used, **payload)
+                return _normalize_genai_response(response)
+            except Exception as e:
+                last_exc = e
+                msg = str(e).lower()
+                if any(k in msg for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit")):
+                    pass
+                else:
+                    raise
+        if time.time() - start > timeout:
+            raise TimeoutError(f"Responses.generate timed out after {timeout}s: last error: {last_exc}")
+        time.sleep(backoff)
+        backoff = min(backoff * 2, 8.0)
+
 def _normalize_genai_response(response):
-    import json
+    outputs = []
     if response is None:
         return ""
-    try:
-        if not isinstance(response, dict):
+
+    if not isinstance(response, dict):
+        try:
             response = json.loads(str(response))
-    except Exception:
-        pass
+        except Exception:
+            pass
+
     candidate_lists = []
     if isinstance(response, dict):
         for key in ("output", "candidates", "items", "responses", "choices"):
@@ -213,6 +373,7 @@ def _normalize_genai_response(response):
             if isinstance(v, list) and v:
                 candidate_lists.append(v)
                 break
+
     text_pieces = []
     for lst in candidate_lists:
         for item in lst:
@@ -242,12 +403,14 @@ def _normalize_genai_response(response):
                         text_pieces.append(str(t).strip())
                 except Exception:
                     pass
+
     if not text_pieces and isinstance(response, dict):
         for k in ("text", "message", "output_text"):
             v = response.get(k)
             if v:
                 text_pieces.append(str(v).strip())
                 break
+
     seen = set()
     filtered = []
     for t in text_pieces:
@@ -258,169 +421,17 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
-def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300, progress_callback=None):
-    key = get_effective_api_key()
-    if not key:
-        raise RuntimeError("No API key provided")
-    if genai is not None and hasattr(genai, "configure"):
-        try:
-            genai.configure(api_key=key)
-        except Exception:
-            pass
-    fname = file_name_or_id(processed) or None
-    system_msg = {"role": "system", "content": prompt_text}
-    user_msg = {"role": "user", "content": f"Please summarize the attached video: {fname or '[uploaded file]'}."}
-    call_variants = [
-        ("responses.generate", {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}] if fname else None, "max_output_tokens": max_tokens}),
-        ("responses.generate_alt", {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}] if fname else None, "max_output_tokens": max_tokens}),
-        ("legacy_create", {"model": model_used, "input": prompt_text, "file": fname, "max_output_tokens": max_tokens}),
-    ]
-    def is_transient_error(e_text: str):
-        txt = str(e_text).lower()
-        return any(k in txt for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit", "503", "502", "500"))
-    start = time.time()
-    last_exc = None
-    backoff = 1.0
-    attempts = 0
-    while True:
-        for method_name, payload in call_variants:
-            attempts += 1
-            try:
-                if genai_responses is not None and hasattr(genai_responses, "generate"):
-                    payload = {k: v for k, v in payload.items() if v is not None}
-                    resp = genai_responses.generate(**payload)
-                    text = _normalize_genai_response(resp)
-                    if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
-                        raise RuntimeError("Model indicates it didn't receive the file")
-                    return text
-                if hasattr(genai, "Responses") and hasattr(genai.Responses, "create"):
-                    payload = {k: v for k, v in payload.items() if v is not None}
-                    resp = genai.Responses.create(**payload)  # type: ignore
-                    text = _normalize_genai_response(resp)
-                    if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
-                        raise RuntimeError("Model indicates it didn't receive the file")
-                    return text
-                if hasattr(genai, "GenerativeModel"):
-                    try:
-                        model_obj = genai.GenerativeModel(model_name=model_used)
-                        if hasattr(model_obj, "start_chat"):
-                            chat = model_obj.start_chat()
-                            send = getattr(chat, "send_message", None)
-                            if send is None:
-                                raise RuntimeError("ChatSession has no send_message")
-                            try:
-                                resp = send(prompt_text, timeout=timeout)
-                            except TypeError:
-                                resp = send(prompt_text)
-                            text = getattr(resp, "text", None) or str(resp)
-                            text = text if text else _normalize_genai_response(resp)
-                            if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
-                                raise RuntimeError("Model indicates it didn't receive the file")
-                            return text
-                    except Exception:
-                        logger.exception("GenerativeModel.chat fallback failed")
-                raise RuntimeError("No supported response generation method available in installed google-generativeai package.")
-            except Exception as e:
-                last_exc = e
-                msg = str(e)
-                logger.warning("Generation error (model=%s attempt=%s method=%s): %s", model_used, attempts, method_name, msg)
-                if not is_transient_error(msg):
-                    if "No supported response generation method" in msg or "has no attribute" in msg or "didn't receive the file" in msg:
-                        raise RuntimeError(
-                            "Installed google-generativeai package may not expose a compatible Responses API or the SDK didn't attach the file correctly. "
-                            "Try upgrading the SDK: pip install --upgrade google-generativeai."
-                        ) from e
-                    raise
-                if time.time() - start > timeout:
-                    raise TimeoutError(f"Responses.generate timed out after {timeout}s: last error: {last_exc}")
-                time.sleep(backoff)
-                backoff = min(backoff * 2, 8.0)
-
-def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_threshold: float = 0.68):
-    if not prompt or not text:
-        return text
-    a = " ".join(prompt.strip().lower().split())
-    b_full = text.strip()
-    b = " ".join(b_full[:check_len].lower().split())
-    ratio = SequenceMatcher(None, a, b).ratio()
-    if ratio >= ratio_threshold:
-        cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
-        new_text = b_full[cut:].lstrip(" \n:-")
-        if len(new_text) >= 3:
-            return new_text
-    placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
-    low = b_full.strip().lower()
-    for ph in placeholders:
-        if low.startswith(ph):
-            return b_full[len(ph):].lstrip(" \n:-")
-    return text
-
-# reset on URL change
-current_url = st.session_state.get("url_input", "")
-if current_url != st.session_state.get("last_url_value"):
-    st.session_state["videos"] = ""
-    st.session_state["last_loaded_path"] = ""
-    st.session_state["uploaded_file"] = None
-    st.session_state["processed_file"] = None
-    st.session_state["analysis_out"] = ""
-    st.session_state["last_error"] = ""
-    st.session_state["file_hash"] = None
-    for f in glob(str(DATA_DIR / "*")):
-        try:
-            os.remove(f)
-        except Exception:
-            pass
-    st.session_state["last_url_value"] = current_url
-
-st.sidebar.header("Video Input")
-st.sidebar.text_input("Video URL", key="url_input", placeholder="https://", value=st.session_state.get("url_input", ""))
-
-settings_exp = st.sidebar.expander("Settings", expanded=False)
-
-# compute initial index safely
-initial_index = 0
-try:
-    cur = st.session_state.get("model_select", st.session_state.get("preferred_model"))
-    initial_index = MODEL_OPTIONS.index(cur) if cur in MODEL_OPTIONS else MODEL_OPTIONS.index(st.session_state.get("preferred_model"))
-except Exception:
-    initial_index = 0
-
-# let the widget own st.session_state["model_select"]; do not assign into it later
-with settings_exp:
-    st.selectbox("Gemini model", MODEL_OPTIONS, index=initial_index, key="model_select")
-    if st.session_state.get("model_select") == "custom":
-        st.text_input("Custom model name", value=st.session_state.get("custom_model", ""), key="custom_model")
-    model_input_value = (st.session_state.get("custom_model") or st.session_state.get("model_select")).strip()
-
-    st.text_input("Google API Key", key="api_key_input", value=st.session_state.get("api_key", ""), type="password")
-
-    default_prompt = (
-        "Watch the video and provide a detailed behavioral report focusing on human actions, interactions, posture, movement, and apparent intent. Keep language professional. Include a list of observations for notable events."
-    )
-    st.text_area("Enter analysis prompt", value=st.session_state.get("analysis_prompt", default_prompt), height=140, key="analysis_prompt")
-
-    st.text_input("Video Password (if needed)", key="video_password_input", placeholder="password", type="password")
-
-    st.number_input("Processing timeout (s)", min_value=60, max_value=3600, value=st.session_state.get("processing_timeout", 900), step=30, key="processing_timeout_input")
-    st.number_input("Generation timeout (s)", min_value=30, max_value=1800, value=st.session_state.get("generation_timeout", 300), step=10, key="generation_timeout_input")
-    st.number_input("Compression threshold (MB)", min_value=10, max_value=2000, value=st.session_state.get("compression_threshold_mb", 200), step=10, key="compression_threshold_input")
-
-    key_source = "session" if st.session_state.get("api_key") else ".env" if os.getenv("GOOGLE_API_KEY") else "none"
-    st.caption(f"Using API key from: {key_source}")
-
-    if not get_effective_api_key():
-        st.warning("No Google API key provided; upload/generation disabled.", icon="⚠️")
-
+# ---- Layout ----
 col1, col2 = st.columns([1, 3])
 with col1:
-    generate_now = st.button("Generate the story", type="primary", disabled=not bool(get_effective_api_key()), key="gen_button")
+    generate_now = st.button("Generate the story", type="primary", disabled=not bool(get_effective_api_key()))
 with col2:
-    pass
+    st.write("")  # placeholder
 
-if st.sidebar.button("Load Video", use_container_width=True, key="load_video_btn"):
+if st.sidebar.button("Load Video", use_container_width=True):
     try:
-        vpw = st.session_state.get("video_password", "")
-        path = download_video_ytdlp(st.session_state.get("url_input", ""), str(DATA_DIR), vpw)
+        vpw = st.session_state.get("video-password", "")
+        path = download_video_ytdlp(st.session_state.get("url", ""), str(DATA_DIR), vpw)
         st.session_state["videos"] = path
         st.session_state["last_loaded_path"] = path
         st.session_state.pop("uploaded_file", None)
@@ -439,26 +450,15 @@ if st.session_state["videos"]:
         st.sidebar.write("Couldn't preview video")
 
     with st.sidebar.expander("Options", expanded=False):
-        loop_checkbox = st.checkbox("Enable Loop", value=st.session_state.get("loop_video", False), key="loop_checkbox")
-        st.session_state["loop_video"] = st.session_state.get("loop_checkbox", st.session_state.get("loop_video", False))
-
-        if st.button("Clear Video(s)", key="clear_videos_btn"):
-            st.session_state["videos"] = ""
-            st.session_state["last_loaded_path"] = ""
-            st.session_state["uploaded_file"] = None
-            st.session_state["processed_file"] = None
-            st.session_state["analysis_out"] = ""
-            st.session_state["last_error"] = ""
-            st.session_state["file_hash"] = None
-            for f in glob(str(DATA_DIR / "*")):
-                try:
-                    os.remove(f)
-                except Exception:
-                    pass
+        loop_checkbox = st.checkbox("Enable Loop", value=st.session_state.get("loop_video", False))
+        st.session_state["loop_video"] = loop_checkbox
+
+        if st.button("Clear Video(s)"):
+            clear_all_video_state()
 
         try:
             with open(st.session_state["videos"], "rb") as vf:
-                st.download_button("Download Video", data=vf, file_name=sanitize_filename(st.session_state["videos"]), mime="video/mp4", use_container_width=True, key="download_video_btn")
+                st.download_button("Download Video", data=vf, file_name=sanitize_filename(st.session_state["videos"]), mime="video/mp4", use_container_width=True)
         except Exception:
             st.sidebar.error("Failed to prepare download")
 
@@ -466,14 +466,12 @@ if st.session_state["videos"]:
     try:
         file_size_mb = os.path.getsize(st.session_state["videos"]) / (1024 * 1024)
         st.sidebar.caption(f"File size: {file_size_mb:.1f} MB")
-        if file_size_mb > st.session_state.get("compression_threshold_mb", 200):
-            st.sidebar.warning("Large file detected — it will be compressed automatically before upload.", icon="⚠️")
-        else:
-            st.sidebar.info("File ≤ threshold — will be uploaded unchanged.")
+        if file_size_mb > st.session_state.get("compress_threshold_mb", 200):
+            st.sidebar.warning(f"Large file detected — it will be compressed automatically before upload (>{st.session_state.get('compress_threshold_mb')} MB).", icon="⚠️")
     except Exception:
         pass
 
-# generation flow
+# ---- Main generation flow ----
 if generate_now and not st.session_state.get("busy"):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -485,14 +483,15 @@ if generate_now and not st.session_state.get("busy"):
             try:
                 st.session_state["busy"] = True
                 try:
-                    if HAS_GENAI and genai is not None and hasattr(genai, "configure"):
+                    if HAS_GENAI and genai is not None:
                         genai.configure(api_key=key_to_use)
                 except Exception:
-                    logger.exception("genai configure failed")
+                    pass
 
-                model_id = model_input_value or st.session_state.get("preferred_model") or "gemini-2.0-flash-lite"
+                model_id = (st.session_state.get("model_input") or model_selected or DEFAULT_MODEL).strip()
                 if st.session_state.get("last_model") != model_id:
                     st.session_state["last_model"] = ""
+                maybe_create_agent(model_id)
 
                 processed = st.session_state.get("processed_file")
                 current_path = st.session_state.get("videos")
@@ -506,25 +505,13 @@ if generate_now and not st.session_state.get("busy"):
                     reupload_needed = False
 
                 if reupload_needed:
-                    if not HAS_GENAI or upload_file is None:
-                        raise RuntimeError("google.generativeai SDK or upload support unavailable; cannot upload video. Use SDK with upload_file support.")
+                    if not HAS_GENAI:
+                        raise RuntimeError("google.generativeai SDK not available; install it.")
                     local_path = current_path
-                    try:
-                        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-                    except Exception:
-                        file_size_mb = None
-
-                    compressed = False
-                    upload_path = local_path
-                    threshold_mb = st.session_state.get("compression_threshold_mb", 200)
-                    if file_size_mb is not None and file_size_mb > threshold_mb:
-                        compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
-                        with st.spinner("Compressing video before upload..."):
-                            upload_path = compress_video(local_path, compressed_path, crf=28, preset="fast")
-                        if upload_path != local_path:
-                            compressed = True
+                    upload_path, compressed = compress_video_if_large(local_path, threshold_mb=st.session_state.get("compress_threshold_mb", 200))
 
                     with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
+                        progress_placeholder = st.empty()
                         try:
                             uploaded = upload_video_sdk(upload_path)
                         except Exception as e:
@@ -535,13 +522,7 @@ if generate_now and not st.session_state.get("busy"):
                     try:
                         processing_placeholder = st.empty()
                         processing_bar = processing_placeholder.progress(0)
-                        def processing_cb(pct, elapsed, state):
-                            try:
-                                processing_bar.progress(min(100, int(pct)))
-                                processing_placeholder.caption(f"State: {state} — elapsed: {elapsed}s")
-                            except Exception:
-                                pass
-                        processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 900), progress_callback=processing_cb)
+                        processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 900))
                         processing_bar.progress(100)
                         processing_placeholder.success("Processing complete")
                     except Exception as e:
@@ -554,28 +535,51 @@ if generate_now and not st.session_state.get("busy"):
                     st.session_state["last_loaded_path"] = current_path
                     st.session_state["file_hash"] = current_hash
 
-                prompt_text = (st.session_state.get("analysis_prompt", "") or "").strip() or default_prompt
+                prompt_text = (analysis_prompt.strip() or DEFAULT_PROMPT).strip()
                 out = ""
                 model_used = model_id
                 max_tokens = 2048 if "2.5" in model_used else 1024
                 est_tokens = max_tokens
 
-                try:
-                    gen_progress_placeholder = st.empty()
-                    gen_status = gen_progress_placeholder.text("Starting generation...")
-                    start_gen = time.time()
-                    def gen_progress_cb(stage, elapsed, info):
-                        try:
-                            gen_status.text(f"Stage: {stage} — elapsed: {elapsed}s — {info}")
-                        except Exception:
-                            pass
-                    out = generate_via_responses_api(prompt_text, st.session_state.get("processed_file"), model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300), progress_callback=gen_progress_cb)
-                    gen_progress_placeholder.text(f"Generation complete in {int(time.time()-start_gen)}s")
-                except Exception as e:
-                    tb = traceback.format_exc()
-                    st.session_state["last_error"] = f"Responses API error: {e}\n\nTraceback:\n{tb}"
-                    st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
-                    out = ""
+                # Try Agent first, fallback to Responses API
+                agent = maybe_create_agent(model_used)
+                debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None, "agent_response_has_text": False}
+                if agent:
+                    debug_info["agent_attempted"] = True
+                    try:
+                        with st.spinner("Generating description via Agent..."):
+                            if not processed:
+                                raise RuntimeError("Processed file missing for agent generation")
+                            agent_response = agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
+                            agent_text = getattr(agent_response, "content", None) or getattr(agent_response, "outputText", None) or None
+                            if not agent_text:
+                                try:
+                                    if isinstance(agent_response, dict):
+                                        for k in ("content", "outputText", "text", "message"):
+                                            if k in agent_response and agent_response[k]:
+                                                agent_text = agent_response[k]
+                                                break
+                                except Exception:
+                                    pass
+                            if agent_text and str(agent_text).strip():
+                                out = str(agent_text).strip()
+                                debug_info["agent_ok"] = True
+                                debug_info["agent_response_has_text"] = True
+                            else:
+                                debug_info["agent_ok"] = False
+                    except Exception as ae:
+                        debug_info["agent_error"] = f"{ae}"
+                        debug_info["agent_traceback"] = traceback.format_exc()
+
+                if not out:
+                    try:
+                        with st.spinner("Generating description via Responses API..."):
+                            out = generate_via_responses_api(prompt_text, processed, model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300))
+                    except Exception as e:
+                        tb = traceback.format_exc()
+                        st.session_state["last_error"] = f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{tb}"
+                        st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
+                        out = ""
 
                 if out:
                     out = remove_prompt_echo(prompt_text, out)
@@ -598,7 +602,7 @@ if generate_now and not st.session_state.get("busy"):
 
             except Exception as e:
                 tb = traceback.format_exc()
-                st.session_state["last_error"] = f"{e}\n\nTraceback:\n{tb}"
+                st.session_state["last_error"] = f"{e}\n\nDebug: {locals().get('debug_info', {})}\n\nTraceback:\n{tb}"
                 st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
             finally:
                 st.session_state["busy"] = False