Update streamlit_app.py

streamlit_app.py

@@ -5,8 +5,8 @@ import string
 import hashlib
 import traceback
 import inspect
-import re
 import json
+import re
 from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
@@ -21,13 +21,10 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-# Remove phi agent code (fragile imports); keep simple flag
+# Feature flags
 HAS_PHI = False
-
-# google generative ai SDK (may be absent or partial in some runtimes)
 try:
     import google.generativeai as genai  # type: ignore
-    # upload_file/get_file exist in some versions
     try:
         from google.generativeai import upload_file, get_file  # type: ignore
     except Exception:
@@ -45,22 +42,26 @@ DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
 # Session defaults
-st.session_state.setdefault("videos", "")
-st.session_state.setdefault("loop_video", False)
-st.session_state.setdefault("uploaded_file", None)
-st.session_state.setdefault("processed_file", None)
-st.session_state.setdefault("busy", False)
-st.session_state.setdefault("last_loaded_path", "")
-st.session_state.setdefault("analysis_out", "")
-st.session_state.setdefault("last_error", "")
-st.session_state.setdefault("file_hash", None)
-st.session_state.setdefault("fast_mode", False)
-st.session_state.setdefault("api_key", os.getenv("GOOGLE_API_KEY", ""))
-st.session_state.setdefault("last_model", "")
-st.session_state.setdefault("last_url_value", "")
+for k, v in {
+    "videos": "",
+    "loop_video": False,
+    "uploaded_file": None,
+    "processed_file": None,
+    "busy": False,
+    "last_loaded_path": "",
+    "analysis_out": "",
+    "last_error": "",
+    "file_hash": None,
+    "fast_mode": False,
+    "api_key": os.getenv("GOOGLE_API_KEY", ""),
+    "last_model": "",
+    "last_url_value": "",
+}.items():
+    st.session_state.setdefault(k, v)
 
 HEADERS = {"User-Agent": "Mozilla/5.0 (compatible)"}
 
+# Utilities --------------------------------------------------------------------
 def sanitize_filename(path_str: str):
     return Path(path_str).name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
 
@@ -89,81 +90,16 @@ def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str
     except Exception:
         return input_path
 
-def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
-    if not url:
-        raise ValueError("No URL provided")
-    outtmpl = str(Path(save_dir) / "%(id)s.%(ext)s")
-    ydl_opts = {"outtmpl": outtmpl, "format": "best"}
-    if video_password:
-        ydl_opts["videopassword"] = video_password
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(url, download=True)
-    video_id = info.get("id") if isinstance(info, dict) else None
-    if video_id:
-        matches = glob(os.path.join(save_dir, f"{video_id}.*"))
-    else:
-        all_files = glob(os.path.join(save_dir, "*"))
-        matches = sorted(all_files, key=os.path.getmtime, reverse=True)[:1] if all_files else []
-    if not matches:
-        raise FileNotFoundError("Downloaded video not found")
-    return convert_video_to_mp4(matches[0])
-
-def file_name_or_id(file_obj):
-    if file_obj is None:
-        return None
-    if isinstance(file_obj, dict):
-        return file_obj.get("name") or file_obj.get("id")
-    for attr in ("name", "id", "fileId", "file_id"):
-        if hasattr(file_obj, attr):
-            val = getattr(file_obj, attr)
-            if val:
-                return val
-    return str(file_obj)
-
-def get_effective_api_key():
-    return st.session_state.get("api_key") or os.getenv("GOOGLE_API_KEY")
-
-def maybe_configure_genai(key):
-    if not key or not HAS_GENAI:
-        return False
-    try:
-        genai.configure(api_key=key)
-        return True
-    except Exception:
-        return False
-
-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
-
-# --- Twitter (t.co / X) helpers integrated into expand/extract flow ---
+# Downloader / extractor ------------------------------------------------------
 def expand_url(short_url, timeout=10):
-    """
-    General URL expander. For t.co/twitter shortlinks we try multiple variants
-    and return final URL and HTML if available.
-    """
     try:
         r = requests.get(short_url, allow_redirects=True, timeout=timeout, headers=HEADERS)
         r.raise_for_status()
-        final = r.url
-        return final, r.text
+        return r.url, r.text
     except Exception as e:
         return None, f"error: {e}"
 
 def extract_video_from_html(html, base_url=None):
-    """
-    Generic extractor tries og:video, <video>, LD+JSON, twitter tags, and links to common hosts.
-    """
     soup = BeautifulSoup(html, "html.parser")
     og = soup.find("meta", property="og:video")
     if og and og.get("content"):
@@ -179,6 +115,7 @@ def extract_video_from_html(html, base_url=None):
     for script in soup.find_all("script", type="application/ld+json"):
         try:
             data = json.loads(script.string or "{}")
+            video = None
             if isinstance(data, dict):
                 video = data.get("video") or data.get("videoObject") or data.get("mainEntity")
                 if isinstance(video, dict):
@@ -189,63 +126,46 @@ def extract_video_from_html(html, base_url=None):
                     return data.get("contentUrl")
         except Exception:
             continue
-    for meta_name in ("twitter:player:stream", "twitter:player"):
-        m = soup.find("meta", attrs={"name": meta_name})
-        if m and m.get("content"):
-            return m.get("content")
+    for mname in ("twitter:player:stream", "twitter:player"):
+        meta = soup.find("meta", attrs={"name": mname})
+        if meta and meta.get("content"):
+            return meta.get("content")
     for a in soup.find_all("a", href=True):
         href = a["href"]
-        if any(domain in href for domain in ("youtube.com", "youtu.be", "vimeo.com")):
+        if any(d in href for d in ("youtube.com", "youtu.be", "vimeo.com")):
             return href
     return None
 
 def extract_video_from_twitter_html(html):
-    """
-    Attempt to pull direct MP4 URL from Twitter/X HTML by searching JSON blobs and OG tags.
-    This is a best-effort extractor and may fail if Twitter/X obfuscates content.
-    """
     soup = BeautifulSoup(html, "html.parser")
-
-    # 1) Open Graph video tag
     og_video = soup.find("meta", property="og:video")
     if og_video and og_video.get("content"):
         return og_video["content"]
-
-    # 2) Look for JSON blobs in <script> tags and search for variants/urls
     scripts = soup.find_all("script")
     for s in scripts:
         txt = s.string
         if not txt:
             continue
-        # crude detect for embedded JSON-ish blobs that include "video_info" or "variants"
-        if "video_info" in txt or "variants" in txt or "playbackUrl" in txt or "media" in txt:
-            # try to extract a JSON object within the script text
+        if any(k in txt for k in ("video_info", "variants", "playbackUrl", "media")):
             m = re.search(r"(?s)(\{.+\})", txt)
             if not m:
                 continue
             try:
                 blob = json.loads(m.group(1))
             except Exception:
-                # sometimes it's not strict JSON; skip
                 continue
-
-            # deep search for urls and variants
             def find_media_urls(obj):
                 if isinstance(obj, dict):
                     for k, v in obj.items():
-                        if isinstance(v, str):
-                            if v.startswith("https://") and v.endswith(".mp4"):
-                                yield v
+                        if isinstance(v, str) and v.startswith("https://") and v.endswith(".mp4"):
+                            yield v
                         else:
                             yield from find_media_urls(v)
                 elif isinstance(obj, list):
                     for it in obj:
                         yield from find_media_urls(it)
-
             for url in find_media_urls(blob):
                 return url
-
-            # also look for variant lists
             def find_variants(obj):
                 if isinstance(obj, dict):
                     for k, v in obj.items():
@@ -261,22 +181,14 @@ def extract_video_from_twitter_html(html):
                 elif isinstance(obj, list):
                     for it in obj:
                         yield from find_variants(it)
-
             for url in find_variants(blob):
                 return url
-
     return None
 
 def extract_direct_twitter_video(url):
-    """
-    Expand t.co and try several page variants (mobile, amp, x.com) and oEmbed.
-    Returns (direct_video_url or None, info_string)
-    """
     final, html_or_err = expand_url(url)
     if final is None:
         return None, html_or_err
-
-    # Try several variants (mobile, x.com, with query params)
     variants = [
         final,
         final.replace("://twitter.com/", "://mobile.twitter.com/"),
@@ -293,8 +205,6 @@ def extract_direct_twitter_video(url):
                 return direct, u
         except Exception:
             continue
-
-    # Try oEmbed as last resort
     try:
         oembed = requests.get("https://publish.twitter.com/oembed?url=" + final, headers=HEADERS, timeout=6)
         if oembed.ok:
@@ -306,16 +216,46 @@ def extract_direct_twitter_video(url):
                 return video["src"], final
     except Exception:
         pass
-
     return None, "not found"
 
-# --- Upload helpers for Generative AI SDK + HTTP fallback (fixed endpoint/use patterns) ---
+def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
+    if not url:
+        raise ValueError("No URL provided")
+    outtmpl = str(Path(save_dir) / "%(id)s.%(ext)s")
+    ydl_opts = {"outtmpl": outtmpl, "format": "best"}
+    if video_password:
+        ydl_opts["videopassword"] = video_password
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+    video_id = info.get("id") if isinstance(info, dict) else None
+    if video_id:
+        matches = glob(os.path.join(save_dir, f"{video_id}.*"))
+    else:
+        all_files = glob(os.path.join(save_dir, "*"))
+        matches = sorted(all_files, key=os.path.getmtime, reverse=True)[:1] if all_files else []
+    if not matches:
+        raise FileNotFoundError("Downloaded video not found")
+    return convert_video_to_mp4(matches[0])
+
+# Generative AI helpers -------------------------------------------------------
+def get_effective_api_key():
+    return st.session_state.get("api_key") or os.getenv("GOOGLE_API_KEY")
+
+def maybe_configure_genai(key):
+    if not key or not HAS_GENAI:
+        return False
+    try:
+        genai.configure(api_key=key)
+        return True
+    except Exception:
+        return False
+
 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 upload not available; cannot upload")
+        raise RuntimeError("google.generativeai SDK upload not available")
     genai.configure(api_key=key)
     return upload_file(filepath)
 
@@ -323,7 +263,14 @@ def wait_for_processed(file_obj, timeout=180):
     if not HAS_GENAI or get_file is None:
         return file_obj
     start = time.time()
-    name = file_name_or_id(file_obj)
+    name = None
+    if isinstance(file_obj, dict):
+        name = file_obj.get("name") or file_obj.get("id")
+    else:
+        for attr in ("name", "id", "fileId", "file_id"):
+            if hasattr(file_obj, attr):
+                name = getattr(file_obj, attr)
+                break
     if not name:
         return file_obj
     backoff = 1.0
@@ -363,18 +310,12 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
     return text
 
 def generative_model_call_flexible(model_name, messages, files=None, max_output_tokens=1024):
-    """
-    Try different call patterns for genai.GenerativeModel depending on its constructor/signature.
-    Do NOT pass unsupported keywords called 'files' into generate_content() if the SDK rejects them.
-    """
     if not HAS_GENAI or genai is None:
         raise RuntimeError("genai not available")
-
     GM = getattr(genai, "GenerativeModel", None)
     if GM is None:
         raise RuntimeError("GenerativeModel not available")
-
-    # Construct instance robustly
+    # robust constructor
     try:
         sig = inspect.signature(GM)
         params = sig.parameters
@@ -384,54 +325,36 @@ def generative_model_call_flexible(model_name, messages, files=None, max_output_
             gm = GM(model_name=model_name)
         else:
             gm = GM()
-            try:
-                if hasattr(gm, "model"):
+            if hasattr(gm, "model"):
+                try:
                     setattr(gm, "model", model_name)
-            except Exception:
-                pass
+                except Exception:
+                    pass
     except Exception:
         try:
             gm = GM(model=model_name)
-        except TypeError:
-            try:
-                gm = GM(model_name=model_name)
-            except TypeError:
-                gm = GM()
-
-    # Now attempt supported generate methods but avoid unsupported kwargs
-    # 1) generate_content(messages...) may accept just messages and options (no files)
+        except Exception:
+            gm = GM()
+    # try generate methods but avoid unsupported kwargs
     if hasattr(gm, "generate_content"):
         try:
-            return gm.generate_content(messages, max_output_tokens=max_output_tokens)
-        except TypeError:
-            # generate_content signature doesn't accept our args; try positional single string fallback
+            # many versions accept 'messages' and 'files'
             try:
-                # some versions expect a string prompt
-                prompt = messages[-1].get("content") if isinstance(messages, (list, tuple)) and messages else str(messages)
-                return gm.generate_content(prompt)
-            except Exception as e:
-                raise RuntimeError(f"GenerativeModel.generate_content unusable: {e}")
-    # 2) generate(...) variants
+                return gm.generate_content(messages=messages, files=files, max_output_tokens=max_output_tokens)
+            except TypeError:
+                return gm.generate_content(messages, max_output_tokens)
+        except Exception as e:
+            raise RuntimeError(f"generate_content failed: {e}")
     if hasattr(gm, "generate"):
         try:
-            return gm.generate(messages, max_output_tokens=max_output_tokens)
+            return gm.generate(messages=messages, files=files, max_output_tokens=max_output_tokens)
         except TypeError:
-            try:
-                return gm.generate(messages)
-            except Exception as e:
-                raise RuntimeError(f"GenerativeModel.generate unusable: {e}")
-
+            return gm.generate(messages, max_output_tokens=max_output_tokens)
     raise RuntimeError("No usable generate method on GenerativeModel instance")
 
 def responses_http_call(api_key, model, messages, file_name=None, max_output_tokens=1024, safety_settings=None):
-    """
-    Fallback to the public Responses API v1 endpoint (modern). Construct a minimal request body.
-    Note: endpoint and schema may change; this uses a simple v1-compatible payload.
-    """
-    # Use the modern Responses v1 endpoint format
-    url = "https://api.generativeai.googleapis.com/v1/models/{model}:generateMessage".format(model=model)
+    url = f"https://api.generativeai.googleapis.com/v1/models/{model}:generateMessage"
     headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-    # Build minimal 'messages' style payload expected by many GenAI endpoints
     payload = {
         "messages": [{"role": m.get("role", "user"), "content": [{"type": "text", "text": m.get("content", "")}]} for m in messages],
         "maxOutputTokens": max_output_tokens,
@@ -439,19 +362,83 @@ def responses_http_call(api_key, model, messages, file_name=None, max_output_tok
     if safety_settings:
         payload["safetySettings"] = safety_settings
     if file_name:
-        # Some endpoints accept files as references
         payload["files"] = [{"name": file_name}]
-    try:
-        r = requests.post(url, json=payload, headers=headers, timeout=60)
-        r.raise_for_status()
-        return r.json()
-    except Exception as e:
-        raise RuntimeError(f"HTTP responses fallback failed: {e}")
+    r = requests.post(url, json=payload, headers=headers, timeout=60)
+    r.raise_for_status()
+    return r.json()
+
+def normalize_response_to_text(response) -> str:
+    """Extract text from SDK or HTTP responses into a single string."""
+    if not response:
+        return ""
+    # dict-like responses (HTTP fallback or genai.responses)
+    if isinstance(response, dict):
+        # modern Responses v1 may include 'output' or 'message'
+        # search keys for lists of candidates/items/responses
+        for list_key in ("output", "candidates", "items", "responses"):
+            val = response.get(list_key)
+            if isinstance(val, (list, tuple)) and val:
+                pieces = []
+                for el in val:
+                    if isinstance(el, dict):
+                        # content field may be list of {type, text}
+                        c = el.get("content") or el.get("message") or el.get("text")
+                        if isinstance(c, list):
+                            for part in c:
+                                if isinstance(part, dict):
+                                    t = part.get("text") or part.get("content")
+                                    if t:
+                                        pieces.append(t)
+                                elif isinstance(part, str):
+                                    pieces.append(part)
+                        elif isinstance(c, str):
+                            pieces.append(c)
+                    elif isinstance(el, str):
+                        pieces.append(el)
+                if pieces:
+                    return "\n\n".join(pieces)
+        # message/content path
+        msg = response.get("message") or response.get("response") or response.get("output")
+        if isinstance(msg, dict):
+            c = msg.get("content")
+            if isinstance(c, list):
+                texts = []
+                for part in c:
+                    if isinstance(part, dict) and "text" in part:
+                        texts.append(part.get("text"))
+                    elif isinstance(part, str):
+                        texts.append(part)
+                return "\n\n".join([t for t in texts if t])
+        # fallback join string values
+        flat = []
+        for v in response.values():
+            if isinstance(v, str) and v.strip():
+                flat.append(v.strip())
+        return "\n\n".join(flat)
+    # object-like SDK responses
+    for attr in ("output", "candidates", "items", "responses", "message"):
+        val = getattr(response, attr, None)
+        if isinstance(val, (list, tuple)) and val:
+            pieces = []
+            for el in val:
+                if hasattr(el, "text"):
+                    pieces.append(getattr(el, "text"))
+                elif isinstance(el, dict):
+                    t = el.get("text") or el.get("content")
+                    if t:
+                        pieces.append(t)
+                else:
+                    pieces.append(str(el))
+            return "\n\n".join([p for p in pieces if p])
+    # fallback
+    text = getattr(response, "text", None) or getattr(response, "message", None)
+    return text or ""
 
-# UI layout
+# UI --------------------------------------------------------------------------
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url_value"):
-    clear_all_video_state()
+    # clear when user changes URL
+    st.session_state.update({"videos": "", "uploaded_file": None, "processed_file": None, "last_loaded_path": "", "analysis_out": "", "last_error": "", "file_hash": None})
     st.session_state["last_url_value"] = current_url
 
 st.sidebar.header("Video Input")
@@ -469,7 +456,6 @@ settings_exp.checkbox("Fast mode (skip compression, smaller model, fewer tokens)
 
 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="⚠️")
 
@@ -486,7 +472,7 @@ with col1:
 with col2:
     pass
 
-# Load Video flow: expand short URLs and try to extract direct video links from HTML before yt-dlp
+# Load Video button
 if st.sidebar.button("Load Video", use_container_width=True):
     try:
         vpw = st.session_state.get("video-password", "")
@@ -495,14 +481,11 @@ if st.sidebar.button("Load Video", use_container_width=True):
         html_text = None
         extracted = None
         if url_val:
-            # Special handling for t.co / twitter shortlinks
             if "t.co/" in url_val or ("twitter.com" in url_val or "x.com" in url_val):
                 extracted, src_info = extract_direct_twitter_video(url_val)
                 if extracted:
                     final_url = extracted
-                    html_text = None
                 else:
-                    # fallback to expand_url to get final page HTML
                     expanded, html_or_err = expand_url(url_val)
                     if expanded:
                         final_url = expanded
@@ -512,42 +495,39 @@ if st.sidebar.button("Load Video", use_container_width=True):
                 if expanded:
                     final_url = expanded
                     html_text = html_or_err
-
         if html_text and not extracted:
             extracted = extract_video_from_html(html_text, base_url=final_url)
         target_url_for_ytdlp = extracted or final_url
         path = download_video_ytdlp(target_url_for_ytdlp, str(DATA_DIR), vpw)
         st.session_state["videos"] = path
         st.session_state["last_loaded_path"] = path
-        st.session_state.pop("uploaded_file", None)
-        st.session_state.pop("processed_file", None)
-        try:
-            st.session_state["file_hash"] = file_sha256(path)
-        except Exception:
-            st.session_state["file_hash"] = None
+        st.session_state["file_hash"] = file_sha256(path) if os.path.exists(path) else None
+        st.session_state["uploaded_file"] = None
+        st.session_state["processed_file"] = None
     except Exception as e:
         st.sidebar.error(f"Failed to load video: {e}")
 
-# Player / sidebar controls
+# Sidebar preview + controls
 if st.session_state["videos"]:
     try:
         st.sidebar.video(st.session_state["videos"], loop=st.session_state.get("loop_video", False))
     except Exception:
         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))
         st.session_state["loop_video"] = loop_checkbox
-
         if st.button("Clear Video(s)"):
-            clear_all_video_state()
-
+            for f in glob(str(DATA_DIR / "*")):
+                try:
+                    os.remove(f)
+                except Exception:
+                    pass
+            st.session_state.update({"videos": "", "uploaded_file": None, "processed_file": None, "last_loaded_path": "", "analysis_out": "", "last_error": "", "file_hash": None})
         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)
         except Exception:
             st.sidebar.error("Failed to prepare download")
-
     st.sidebar.write("Title:", Path(st.session_state["videos"]).name)
     try:
         file_size_mb = os.path.getsize(st.session_state["videos"]) / (1024 * 1024)
@@ -557,7 +537,7 @@ if st.session_state["videos"]:
     except Exception:
         pass
 
-# Generation flow (robust handling of google.generativeai variants)
+# 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.")
@@ -566,43 +546,29 @@ if generate_now and not st.session_state.get("busy"):
         if not key_to_use:
             st.error("Google API key not set.")
         else:
+            st.session_state["busy"] = True
             try:
-                st.session_state["busy"] = True
                 maybe_configure_genai(key_to_use)
-
                 model_id = (st.session_state.get("model_input") or "gemini-2.5-flash-lite").strip()
-                if st.session_state.get("last_model") != model_id:
-                    st.session_state["last_model"] = ""
-                processed = st.session_state.get("processed_file")
                 current_path = st.session_state.get("videos")
-                try:
-                    current_hash = file_sha256(current_path) if current_path and os.path.exists(current_path) else None
-                except Exception:
-                    current_hash = None
+                current_hash = file_sha256(current_path) if current_path and os.path.exists(current_path) else None
 
                 reupload_needed = True
+                processed = st.session_state.get("processed_file")
                 if processed and st.session_state.get("last_loaded_path") == current_path and st.session_state.get("file_hash") == current_hash:
                     reupload_needed = False
 
+                upload_path = current_path
                 if reupload_needed:
-                    if not HAS_GENAI:
-                        raise RuntimeError("google.generativeai SDK not available; install it.")
-                    local_path = current_path
+                    # compress if large and not fast
                     fast_mode = st.session_state.get("fast_mode", False)
-                    upload_path = local_path
                     try:
-                        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
+                        file_size_mb = os.path.getsize(current_path) / (1024 * 1024)
                     except Exception:
                         file_size_mb = 0
-
                     if not fast_mode and file_size_mb > 50:
-                        compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
-                        try:
-                            preset = "veryfast" if fast_mode else "fast"
-                            upload_path = compress_video(local_path, compressed_path, crf=28, preset=preset)
-                        except Exception:
-                            upload_path = local_path
-
+                        compressed_path = str(Path(current_path).with_name(Path(current_path).stem + "_compressed.mp4"))
+                        upload_path = compress_video(current_path, compressed_path, crf=28, preset="fast")
                     with st.spinner("Uploading video..."):
                         uploaded = upload_video_sdk(upload_path)
                         processed = wait_for_processed(uploaded, timeout=180)
@@ -611,204 +577,88 @@ 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", "").strip() or default_prompt).strip()
-
-                out = ""
-                model_used = model_id
-                max_tokens = 256 if st.session_state.get("fast_mode") else 1024
-                est_tokens = max_tokens
-
-                debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None}
-
-                if not out:
+                prompt_text = (st.session_state.get("analysis_prompt", "") or default_prompt).strip()
+                system_msg = {"role": "system", "content": prompt_text}
+                user_msg = {"role": "user", "content": "Please summarize the attached video."}
+                fname = None
+                if processed:
+                    if isinstance(processed, dict):
+                        fname = processed.get("name") or processed.get("id")
+                    else:
+                        for attr in ("name", "id", "fileId", "file_id"):
+                            if hasattr(processed, attr):
+                                fname = getattr(processed, attr)
+                                break
+                # prefer SDK methods that support 'files' / file references
+                response = None
+                diagnostics = {"attempts": []}
+
+                # 1) genai.responses.generate (if available) - supports files param
+                if response is None and HAS_GENAI and genai is not None and hasattr(genai, "responses") and hasattr(genai.responses, "generate"):
                     try:
-                        if not HAS_GENAI or genai is None:
-                            raise RuntimeError("Responses API not available; install google.generativeai SDK.")
-                        # ensure configured (best-effort)
-                        try:
-                            genai.configure(api_key=key_to_use)
-                        except Exception:
-                            pass
-
-                        fname = file_name_or_id(processed)
-                        if not fname:
-                            raise RuntimeError("Uploaded file missing name/id")
+                        diagnostics["attempts"].append("responses.generate")
+                        response = genai.responses.generate(
+                            model=model_id,
+                            messages=[system_msg, user_msg],
+                            files=[{"name": fname}] if fname else None,
+                            safety_settings=safety_settings,
+                            max_output_tokens=(256 if st.session_state.get("fast_mode") else 1024),
+                        )
+                    except Exception as e:
+                        diagnostics["responses.generate_error"] = str(e)
+                        response = None
 
-                        system_msg = {"role": "system", "content": prompt_text}
-                        user_msg = {"role": "user", "content": "Please summarize the attached video."}
+                # 2) GenerativeModel flexible call
+                if response is None and HAS_GENAI and genai is not None and hasattr(genai, "GenerativeModel"):
+                    try:
+                        diagnostics["attempts"].append("GenerativeModel")
+                        response = generative_model_call_flexible(model_id, [system_msg, user_msg], files=[{"name": fname}] if fname else None, max_output_tokens=(256 if st.session_state.get("fast_mode") else 1024))
+                    except Exception as e:
+                        diagnostics["GenerativeModel_error"] = str(e)
+                        response = None
 
+                # 3) top-level legacy helpers
+                if response is None and HAS_GENAI and genai is not None:
+                    try:
+                        if hasattr(genai, "generate"):
+                            diagnostics["attempts"].append("top.generate")
+                            response = genai.generate(model=model_id, input=[{"text": prompt_text, "files": [{"name": fname}]}], max_output_tokens=(256 if st.session_state.get("fast_mode") else 1024))
+                        elif hasattr(genai, "create"):
+                            diagnostics["attempts"].append("top.create")
+                            response = genai.create(model=model_id, input=[{"text": prompt_text, "files": [{"name": fname}]}], max_output_tokens=(256 if st.session_state.get("fast_mode") else 1024))
+                    except Exception as e:
+                        diagnostics["top_level_error"] = str(e)
                         response = None
-                        diagnostics = {"attempts": []}
-
-                        # Attempt #1: genai.responses.generate (modern public SDK)
-                        try:
-                            if hasattr(genai, "responses") and hasattr(genai.responses, "generate"):
-                                diagnostics["attempts"].append("responses.generate")
-                                response = genai.responses.generate(
-                                    model=model_used,
-                                    messages=[system_msg, user_msg],
-                                    files=[{"name": fname}],
-                                    safety_settings=safety_settings,
-                                    max_output_tokens=max_tokens,
-                                )
-                        except Exception as e:
-                            diagnostics["responses.generate_error"] = str(e)
-                            response = None
-
-                        # Attempt #2: GenerativeModel variants (0.8.x+), using flexible caller
-                        if response is None:
-                            try:
-                                if hasattr(genai, "GenerativeModel"):
-                                    diagnostics["attempts"].append("GenerativeModel")
-                                    # generative_model_call_flexible avoids passing unsupported 'files' kwarg
-                                    response = generative_model_call_flexible(model_used, [system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
-                            except Exception as e:
-                                diagnostics["GenerativeModel_error"] = str(e)
-                                response = None
-
-                        # Attempt #3: top-level legacy helpers
-                        if response is None:
-                            try:
-                                if hasattr(genai, "generate"):
-                                    diagnostics["attempts"].append("top.generate")
-                                    response = genai.generate(model=model_used, input=[{"text": prompt_text, "files": [{"name": fname}]}], max_output_tokens=max_tokens)
-                                elif hasattr(genai, "create"):
-                                    diagnostics["attempts"].append("top.create")
-                                    response = genai.create(model=model_used, input=[{"text": prompt_text, "files": [{"name": fname}]}], max_output_tokens=max_tokens)
-                            except Exception as e:
-                                diagnostics["top_level_error"] = str(e)
-                                response = None
-
-                        # Attempt #4: fallback HTTP Responses call (modern endpoint)
-                        if response is None:
-                            try:
-                                diagnostics["attempts"].append("http_fallback")
-                                response = responses_http_call(key_to_use, model_used, [system_msg, user_msg], file_name=fname, max_output_tokens=max_tokens, safety_settings=safety_settings)
-                            except Exception as e:
-                                diagnostics["http_fallback_error"] = str(e)
-                                response = None
-
-                        if response is None:
-                            diag_text = f"No supported generate method found on google.generativeai in this runtime. Diagnostics: {diagnostics}"
-                            st.session_state["last_error"] = diag_text
-                            st.error("Responses API not supported in this runtime. See Last Error for details.")
-                            out = ""
-                        else:
-                            # Normalize outputs into text pieces
-                            outputs = []
-                            try:
-                                if isinstance(response, dict):
-                                    for key in ("output", "candidates", "items", "responses"):
-                                        val = response.get(key)
-                                        if isinstance(val, (list, tuple)) and val:
-                                            outputs = list(val)
-                                            break
-                                    if not outputs:
-                                        # some Responses v1 return {'message': {...}}
-                                        msg = response.get("message") or response.get("response") or response.get("output")
-                                        if isinstance(msg, dict):
-                                            # try to extract text from structured message
-                                            c = msg.get("content")
-                                            if isinstance(c, list):
-                                                for part in c:
-                                                    if isinstance(part, dict) and part.get("type") == "output_text":
-                                                        outputs.append({"text": part.get("text")})
-                                                    elif isinstance(part, dict) and part.get("type") == "text":
-                                                        outputs.append({"text": part.get("text")})
-                                        else:
-                                            # fallback: join string values
-                                            for v in response.values():
-                                                if isinstance(v, str) and v.strip():
-                                                    outputs.append({"text": v.strip()})
-                                else:
-                                    for attr in ("output", "candidates", "items", "responses"):
-                                        val = getattr(response, attr, None)
-                                        if isinstance(val, (list, tuple)) and val:
-                                            try:
-                                                outputs = list(val)
-                                            except Exception:
-                                                outputs = val
-                                            break
-                            except Exception:
-                                outputs = []
-
-                            if not outputs:
-                                candidate_text = None
-                                if isinstance(response, dict):
-                                    candidate_text = response.get("text") or response.get("message") or response.get("output_text")
-                                else:
-                                    candidate_text = getattr(response, "text", None) or getattr(response, "message", None)
-                                if candidate_text:
-                                    outputs = [{"text": candidate_text}]
-
-                            text_pieces = []
-                            for item in outputs:
-                                if not item:
-                                    continue
-                                if isinstance(item, dict):
-                                    # common dict shapes
-                                    for k in ("content", "text", "message", "output_text", "output"):
-                                        v = item.get(k)
-                                        if v:
-                                            if isinstance(v, str):
-                                                text_pieces.append(v.strip())
-                                            elif isinstance(v, (list, tuple)):
-                                                for e in v:
-                                                    if isinstance(e, str):
-                                                        text_pieces.append(e.strip())
-                                                    elif isinstance(e, dict):
-                                                        t = e.get("text") or e.get("content")
-                                                        if t:
-                                                            text_pieces.append(str(t).strip())
-                                            break
-                                else:
-                                    for k in ("content", "text", "message", "output", "output_text"):
-                                        v = getattr(item, k, None)
-                                        if v:
-                                            if isinstance(v, str):
-                                                text_pieces.append(v.strip())
-                                            elif isinstance(v, (list, tuple)):
-                                                for e in v:
-                                                    if isinstance(e, str):
-                                                        text_pieces.append(e.strip())
-                                                    else:
-                                                        t = getattr(e, "text", None) or getattr(e, "content", None)
-                                                        if t:
-                                                            text_pieces.append(str(t).strip())
-                                            break
-
-                            seen = set()
-                            filtered = []
-                            for t in text_pieces:
-                                if t and t not in seen:
-                                    filtered.append(t)
-                                    seen.add(t)
-                            out = "\n\n".join(filtered)
 
+                # 4) HTTP fallback to Responses endpoint (supports file references)
+                if response is None:
+                    try:
+                        diagnostics["attempts"].append("http_fallback")
+                        response = responses_http_call(key_to_use, model_id, [system_msg, user_msg], file_name=fname, max_output_tokens=(256 if st.session_state.get("fast_mode") else 1024), safety_settings=safety_settings)
                     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)
-                    p = prompt_text
-                    if p and out.strip().lower().startswith(p.lower()):
-                        out = out.strip()[len(p):].lstrip(" \n:-")
+                        diagnostics["http_fallback_error"] = str(e)
+                        response = None
+
+                if response is None:
+                    st.session_state["last_error"] = f"No supported generation method found. Diagnostics: {diagnostics}"
+                    st.error("Unable to call a supported Responses method in this runtime. See Last Error.")
+                    out = ""
+                else:
+                    out = normalize_response_to_text(response)
+                    out = remove_prompt_echo(prompt_text, out).strip()
+                    # additional cleanup of obvious echoes/placeholders
                     placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
                     low = out.strip().lower()
                     for ph in placeholders:
                         if low.startswith(ph):
                             out = out.strip()[len(ph):].lstrip(" \n:-")
                             break
-                    out = out.strip()
 
                 st.session_state["analysis_out"] = out
                 st.session_state["last_error"] = "" if out else st.session_state.get("last_error", "")
                 st.subheader("Analysis Result")
                 st.markdown(out if out else "No analysis returned.")
-                st.caption(f"Est. max tokens: {est_tokens}")
+                st.caption(f"Est. max tokens: {256 if st.session_state.get('fast_mode') else 1024}")
 
             except Exception as e:
                 tb = traceback.format_exc()