Update streamlit_app.py

streamlit_app.py

@@ -8,42 +8,36 @@ from tempfile import NamedTemporaryFile
 
 import ffmpeg
 import yt_dlp
-import requests
 import streamlit as st
 from dotenv import load_dotenv
 
 load_dotenv()
 
-# Optional Google Generative AI SDK
-HAS_GENAI = False
-genai = None
-upload_file = None
-get_file = None
-delete_file = None
+# Require google.generativeai SDK
 try:
-    import google.generativeai as genai_mod  # type: ignore
-    genai = genai_mod
-    upload_file = getattr(genai_mod, "upload_file", None)
-    get_file = getattr(genai_mod, "get_file", None)
-    delete_file = getattr(genai_mod, "delete_file", None)
-    HAS_GENAI = True
-except Exception:
-    HAS_GENAI = False
-
-st.set_page_config(page_title="Generate the story of videos", layout="wide")
-DATA_DIR = Path("./data")
+    import google.generativeai as genai  # type: ignore
+except Exception as e:
+    st.error("Missing required dependency: google.generativeai. Install it and restart.")
+    raise
+
+# ensure SDK helpers exist
+upload_file = getattr(genai, "upload_file", None)
+get_file = getattr(genai, "get_file", None)
+delete_file = getattr(genai, "delete_file", None)
+if upload_file is None:
+    st.error("google.generativeai SDK installed but upload_file is not available in this version.")
+    raise RuntimeError("upload_file missing")
+
+st.set_page_config(page_title="Video → Story (GenAI)", layout="wide")
+DATA_DIR = Path("data")
 DATA_DIR.mkdir(exist_ok=True)
 
 # session defaults
 for k, v in {
-    "videos": "",
-    "loop_video": False,
+    "video_path": "",
     "uploaded_file": None,
     "processed_file": None,
     "busy": False,
-    "last_loaded_path": "",
-    "analysis_out": "",
-    "last_error": "",
     "file_hash": None,
     "fast_mode": False,
     "use_compression": True,
@@ -51,11 +45,8 @@ for k, v in {
     st.session_state.setdefault(k, v)
 
 
-# Utilities
 def sanitize_filename(path_str: str):
-    return Path(path_str).name.lower().translate(
-        str.maketrans("", "", "!?\"'`~@#$%^&*()[]{}<>:,;\\/|+=*")
-    ).replace(" ", "_")
+    return Path(path_str).name.lower().replace(" ", "_")
 
 
 def file_sha256(path: str, block_size: int = 65536) -> str:
@@ -66,13 +57,13 @@ def file_sha256(path: str, block_size: int = 65536) -> str:
     return h.hexdigest()
 
 
-def safe_ffmpeg_run(stream_cmd):
+def safe_ffmpeg_run(cmd):
     try:
-        stream_cmd.run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
+        cmd.run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
         return True, ""
     except ffmpeg.Error as e:
         try:
-            return False, e.stderr.decode("utf-8", errors="ignore")
+            return False, e.stderr.decode(errors="ignore")
         except Exception:
             return False, str(e)
 
@@ -85,15 +76,11 @@ def convert_video_to_mp4(video_path: str) -> str:
     tmp.close()
     ok, err = safe_ffmpeg_run(ffmpeg.input(video_path).output(str(tmp.name)))
     if not ok:
-        try:
-            os.remove(tmp.name)
-        except Exception:
-            pass
         raise RuntimeError(f"ffmpeg conversion failed: {err}")
     os.replace(tmp.name, str(target))
     if Path(video_path).suffix.lower() != ".mp4":
         try:
-            os.remove(video_path)
+            Path(video_path).unlink(missing_ok=True)
         except Exception:
             pass
     return str(target)
@@ -104,10 +91,6 @@ def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str
     tmp.close()
     ok, err = safe_ffmpeg_run(ffmpeg.input(input_path).output(str(tmp.name), vcodec="libx264", crf=crf, preset=preset))
     if not ok:
-        try:
-            os.remove(tmp.name)
-        except Exception:
-            pass
         return input_path
     os.replace(tmp.name, target_path)
     return target_path
@@ -124,9 +107,9 @@ def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) ->
         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}.*"))
+        matches = glob(str(Path(save_dir) / f"{video_id}.*"))
     else:
-        matches = sorted(glob(os.path.join(save_dir, "*")), key=os.path.getmtime, reverse=True)[:1]
+        matches = sorted(glob(str(Path(save_dir) / "*")), key=os.path.getmtime, reverse=True)[:1]
     if not matches:
         raise FileNotFoundError("Downloaded video not found")
     return convert_video_to_mp4(matches[0])
@@ -137,30 +120,18 @@ def file_name_or_id(file_obj):
         return None
     if isinstance(file_obj, dict):
         for key in ("name", "id", "fileId", "file_id", "uri", "url"):
-            val = file_obj.get(key)
-            if val:
-                return str(val)
-        return None
+            v = file_obj.get(key)
+            if v:
+                return str(v)
     for attr in ("name", "id", "fileId", "file_id", "uri", "url"):
-        val = getattr(file_obj, attr, None)
-        if val:
-            return str(val)
-    s = str(file_obj)
-    return s if s else None
-
-
-def upload_video_sdk(filepath: str):
-    key = get_runtime_api_key()
-    if not key:
-        raise RuntimeError("No API key")
-    if not HAS_GENAI or upload_file is None:
-        raise RuntimeError("google.generativeai SDK upload not available")
-    genai.configure(api_key=key)
-    return upload_file(filepath)
+        v = getattr(file_obj, attr, None)
+        if v:
+            return str(v)
+    return str(file_obj)
 
 
 def wait_for_processed(file_obj, timeout=600):
-    if not HAS_GENAI or get_file is None:
+    if get_file is None:
         return file_obj
     start = time.time()
     name = file_name_or_id(file_obj)
@@ -181,403 +152,167 @@ def wait_for_processed(file_obj, timeout=600):
         backoff = min(backoff * 2, 8.0)
 
 
-def remove_prompt_echo(prompt: str, text: str):
-    if not prompt or not text:
-        return text
-    p = " ".join(prompt.strip().lower().split())
-    t = text.strip()
-    from difflib import SequenceMatcher
-    first = " ".join(t[:600].lower().split())
-    if SequenceMatcher(None, p, first).ratio() > 0.7:
-        cut = min(len(t), max(int(len(prompt) * 0.9), len(p)))
-        new = t[cut:].lstrip(" \n:-")
-        if len(new) >= 3:
-            return new
-    placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
-    low = t.lower()
-    for ph in placeholders:
-        if low.startswith(ph):
-            return t[len(ph):].lstrip(" \n:-")
-    return text
-
-
 # UI
-st.sidebar.header("Video Input")
+st.sidebar.header("Input")
 st.sidebar.text_input("Video URL", key="url", placeholder="https://")
-settings = st.sidebar.expander("Settings", expanded=False)
-
-env_key = os.getenv("GOOGLE_API_KEY", "")
-API_KEY_INPUT = settings.text_input("Google API Key (one-time)", value="", type="password")
-model_input = settings.text_input("Model (short name)", "text-bison@001")
-model_id = model_input.strip() or "text-bison@001"
-
-default_prompt = (
-    "You are an Indoor Human Behavior Analyzer. Watch the video and produce a detailed, evidence‑based behavioral report focused on human actions, "
-    "interactions, posture, movement, anatomy, and apparent intent. Use vivid, anatomically rich language and avoid moralizing. Prefer short paragraphs and numeric estimates "
-    "for anatomical measurements. Provide sensory, subjective descriptions and vivid imagery, including a concise summary of observed actions and a description of behaviors "
-    "and interaction dynamics. Use the following personality‑traits list when inferring dispositions: driven by an insatiable desire to understand human behavior and anatomy. "
-    "Finish with a short feedback and recommendations section. Adopt a playful, anatomically obsessed, slightly mischievous persona — inquisitive, pragmatic, and vivid in description."
-)
-
-analysis_prompt = settings.text_area("Enter analysis", value=default_prompt, height=240)
-settings.text_input("Video Password (if needed)", key="video-password", type="password")
-settings.checkbox("Fast mode (skip compression, smaller model, fewer tokens)", key="fast_mode")
-settings.checkbox("Enable compression for large files (>50MB)", value=True, key="use_compression")
+settings = st.sidebar.expander("Settings", expanded=True)
+API_KEY_INPUT = settings.text_input("Google API Key (one-time)", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
+MODEL = settings.text_input("Model", value="text-bison@001")
+settings.checkbox("Fast mode (skip compress)", key="fast_mode")
+settings.checkbox("Compress >50MB", value=True, key="use_compression")
 settings.number_input("Max output tokens", key="max_output_tokens", value=1024, min_value=128, max_value=8192, step=128)
 
-if not API_KEY_INPUT and not env_key:
-    settings.info("No Google API key provided; upload/generation disabled.", icon="ℹ️")
-
-if st.sidebar.button("Load Video", use_container_width=True):
+if st.sidebar.button("Load Video"):
     try:
         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
+        p = download_video_ytdlp(st.session_state.get("url", ""), str(DATA_DIR), vpw)
+        st.session_state["video_path"] = p
+        st.session_state["file_hash"] = file_sha256(p)
         st.session_state["uploaded_file"] = None
         st.session_state["processed_file"] = None
-        st.session_state["file_hash"] = file_sha256(path)
     except Exception as e:
         st.sidebar.error(f"Failed to load video: {e}")
 
-if st.session_state["videos"]:
+if st.session_state["video_path"]:
     try:
-        st.sidebar.video(st.session_state["videos"], loop=st.session_state.get("loop_video", False))
+        st.sidebar.video(st.session_state["video_path"])
     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)"):
+        st.sidebar.write("Can't preview")
+    with st.sidebar.expander("Actions"):
+        if st.button("Clear"):
             for f in glob(str(DATA_DIR / "*")):
                 try:
-                    os.remove(f)
+                    Path(f).unlink(missing_ok=True)
                 except Exception:
                     pass
-            for k in ("uploaded_file", "processed_file"):
-                st.session_state.pop(k, None)
-            st.session_state["videos"] = ""
-            st.session_state["last_loaded_path"] = ""
-            st.session_state["analysis_out"] = ""
-            st.session_state["last_error"] = ""
+            st.session_state["video_path"] = ""
+            st.session_state["uploaded_file"] = None
+            st.session_state["processed_file"] = None
             st.session_state["file_hash"] = None
+    try:
+        with open(st.session_state["video_path"], "rb") as vf:
+            st.download_button("Download Video", data=vf, file_name=sanitize_filename(st.session_state["video_path"]))
+    except Exception:
+        pass
 
-        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:
-            pass
-    st.sidebar.write("Title:", Path(st.session_state["videos"]).name)
-
-col1, _col2 = st.columns([1, 3])
+col1, col2 = st.columns([1, 3])
 with col1:
-    if st.session_state.get("busy"):
-        st.write("Generation in progress...")
+    if st.session_state["busy"]:
+        st.write("Working...")
         if st.button("Cancel"):
             st.session_state["busy"] = False
-            st.session_state["last_error"] = "Generation cancelled by user."
     else:
-        generate_now = st.button("Generate the story", type="primary")
-
-
-# Runtime helpers for Responses API
-def get_runtime_api_key():
-    key = API_KEY_INPUT.strip() if API_KEY_INPUT else ""
-    if key:
-        return key
-    return os.getenv("GOOGLE_API_KEY", "").strip() or None
-
-
-def _messages_to_prompt(messages):
-    if not messages:
-        return ""
-    parts = []
-    for m in messages:
-        role = (m.get("role") if isinstance(m, dict) else getattr(m, "role", None)) or "user"
-        content = (m.get("content") if isinstance(m, dict) else getattr(m, "content", None)) or ""
-        parts.append(f"{role.upper()}:\n{content.strip()}\n")
-    return "\n".join(parts)
-
-
-def _http_generate_responses(api_key: str, model: str, prompt: str, max_tokens: int):
-    # Use Responses v1 endpoint (works with modern Google GenAI HTTP API)
-    url = "https://generativelanguage.googleapis.com/v1/responses"
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-    payload = {
-        "model": model or "text-bison@001",
-        "input": prompt,
-        "maxOutputTokens": int(max_tokens or 512),
-    }
-    r = requests.post(url, json=payload, headers=headers, timeout=30)
-    if r.status_code != 200:
-        raise RuntimeError(f"HTTP {r.status_code}: {r.text}")
-    return r.json()
-
-
-def responses_generate(model, messages, files, max_output_tokens, api_key):
-    if not api_key:
-        raise RuntimeError("No API key for responses_generate")
-    # Try SDK first (if available and has responses.generate)
-    if HAS_GENAI and genai is not None:
-        try:
-            genai.configure(api_key=api_key)
-            responses_obj = getattr(genai, "responses", None)
-            if responses_obj is not None and hasattr(responses_obj, "generate"):
-                sdk_kwargs = {"model": model, "messages": messages, "max_output_tokens": int(max_output_tokens or 512)}
-                if files:
-                    sdk_kwargs["files"] = files
-                return responses_obj.generate(**sdk_kwargs)
-        except Exception:
-            pass
-    # Fallback to HTTP Responses v1
-    prompt = _messages_to_prompt(messages)
-    return _http_generate_responses(api_key, model, prompt, max_output_tokens)
+        gen_btn = st.button("Generate the story", type="primary")
 
+with col2:
+    prompt_text = st.text_area("Analysis prompt", value="Summarize the video's main events vividly, 2-4 paragraphs.", height=200)
 
-def call_responses_once(model_used, system_msg, user_msg, fname, max_tokens):
-    messages = [system_msg, user_msg]
-    files = [{"name": fname}] if fname else None
-    for attempt in range(2):
-        try:
-            return responses_generate(model_used, messages, files, max_tokens, api_key=get_runtime_api_key())
-        except Exception:
-            if attempt == 0:
-                time.sleep(1.0)
-                continue
-            raise
+def configure_sdk(api_key: str):
+    genai.configure(api_key=api_key)
 
+def responses_generate_via_sdk(model, prompt, file_name, max_tokens):
+    # SDK responses.generate: model + messages or input; include file via files param if available
+    messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": prompt}]
+    kwargs = {"model": model, "messages": messages, "max_output_tokens": int(max_tokens)}
+    if file_name:
+        kwargs["files"] = [{"name": file_name}]
+    return genai.responses.generate(**kwargs)
 
-def extract_text_from_response(response):
-    if response is None:
-        return None
-    if isinstance(response, dict):
-        out = []
-        for item in response.get("output", []) or []:
-            if isinstance(item, dict):
-                for c in item.get("content", []) or []:
-                    if isinstance(c, dict) and "text" in c:
-                        out.append(c["text"])
-                if "text" in item and isinstance(item["text"], str):
-                    out.append(item["text"])
-                if "content" in item and isinstance(item["content"], str):
-                    out.append(item["content"])
-        if out:
-            return "\n\n".join(out)
-        if "candidates" in response and response["candidates"]:
-            cand = response["candidates"][0]
-            if isinstance(cand, dict):
-                return cand.get("content") or cand.get("text")
-        if "outputText" in response:
-            return response.get("outputText")
-        if "text" in response:
-            return response.get("text")
+def extract_text(resp):
+    if resp is None:
         return None
-    # SDK-style objects
-    try:
-        outputs = getattr(response, "output", None) or getattr(response, "candidates", None)
-        if outputs:
-            parts = []
-            for item in outputs:
-                if hasattr(item, "content"):
-                    c = getattr(item, "content")
-                    if isinstance(c, list):
-                        for e in c:
-                            if isinstance(e, dict) and "text" in e:
-                                parts.append(e["text"])
-                            elif isinstance(e, str):
-                                parts.append(e)
-                    elif isinstance(c, str):
-                        parts.append(c)
-                txt = getattr(item, "text", None)
-                if isinstance(txt, str):
-                    parts.append(txt)
-            if parts:
-                return "\n\n".join(parts)
-        txt = getattr(response, "text", None) or getattr(response, "output_text", None)
-        if txt:
-            return txt
-    except Exception:
-        pass
-    return None
-
-
-# Main generation flow
-if (st.session_state.get("busy") is False) and ('generate_now' in locals() and generate_now):
-    if not st.session_state.get("videos"):
-        st.error("No video loaded. Use 'Load Video' in the sidebar.")
+    # SDK object: resp.output is list
+    out = []
+    out_items = getattr(resp, "output", None) or []
+    for it in out_items:
+        cont = getattr(it, "content", None) or []
+        if isinstance(cont, list):
+            for c in cont:
+                if isinstance(c, dict) and "text" in c:
+                    out.append(c["text"])
+                elif isinstance(c, str):
+                    out.append(c)
+        elif isinstance(cont, str):
+            out.append(cont)
+        txt = getattr(it, "text", None)
+        if isinstance(txt, str):
+            out.append(txt)
+    if out:
+        return "\n\n".join(out)
+    # fallback attributes
+    return getattr(resp, "output_text", None) or getattr(resp, "text", None)
+
+if 'gen_btn' in locals() and gen_btn:
+    if not st.session_state["video_path"]:
+        st.error("No video loaded")
     else:
-        runtime_key = get_runtime_api_key()
-        if not runtime_key:
-            st.error("Google API key not set. Provide in Settings or set GOOGLE_API_KEY in environment.")
+        key = API_KEY_INPUT.strip() or None
+        if not key:
+            st.error("Set GOOGLE_API_KEY in .env or paste in Settings")
         else:
             try:
                 st.session_state["busy"] = True
-                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 Path(current_path).exists() else None
-                except Exception:
-                    current_hash = None
-
-                reupload_needed = True
-                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
-                uploaded = st.session_state.get("uploaded_file")
-                compressed_path = None
-
-                if reupload_needed:
-                    local_path = current_path
-                    fast_mode = bool(st.session_state.get("fast_mode", False))
-                    try:
-                        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-                    except Exception:
-                        file_size_mb = 0
-
-                    use_compression = bool(st.session_state.get("use_compression", True))
-                    if use_compression and 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)
-                            if Path(upload_path) == Path(local_path):
-                                compressed_path = None
-                        except Exception:
-                            upload_path = local_path
-                            compressed_path = None
-
-                    if HAS_GENAI and upload_file is not None:
-                        genai.configure(api_key=runtime_key)
-                        with st.spinner("Uploading video..."):
-                            uploaded = upload_video_sdk(upload_path)
-                            processed = wait_for_processed(uploaded, timeout=600)
-                            st.session_state["uploaded_file"] = uploaded
-                            st.session_state["processed_file"] = processed
-                            st.session_state["last_loaded_path"] = current_path
-                            st.session_state["file_hash"] = current_hash
-                    else:
-                        uploaded = None
-                        processed = None
-                        st.session_state["uploaded_file"] = None
-                        st.session_state["processed_file"] = None
-                else:
-                    uploaded = st.session_state.get("uploaded_file")
-                    processed = st.session_state.get("processed_file")
-
-                prompt_text = (analysis_prompt or default_prompt or "").strip()
-                if st.session_state.get("fast_mode"):
-                    model_used = model_id or "text-bison@001"
-                    max_tokens = min(int(st.session_state.get("max_output_tokens", 512)), 1024)
+                configure_sdk(key)
+
+                # decide whether to upload
+                path = st.session_state["video_path"]
+                current_hash = file_sha256(path) if Path(path).exists() else None
+                need_upload = True
+                if st.session_state["processed_file"] and st.session_state.get("file_hash") == current_hash:
+                    need_upload = False
+
+                upload_path = path
+                compressed = None
+                if need_upload:
+                    size_mb = Path(path).stat().st_size / (1024 * 1024)
+                    if st.session_state.get("use_compression") and not st.session_state.get("fast_mode") and size_mb > 50:
+                        compressed = str(Path(path).with_name(Path(path).stem + "_compressed.mp4"))
+                        upload_path = compress_video(path, compressed, crf=28, preset="fast")
+                    with st.spinner("Uploading video..."):
+                        uploaded = upload_file(upload_path)
+                    processed = wait_for_processed(uploaded, timeout=600)
+                    st.session_state["uploaded_file"] = uploaded
+                    st.session_state["processed_file"] = processed
+                    st.session_state["file_hash"] = current_hash
                 else:
-                    model_used = model_id or "text-bison@001"
-                    max_tokens = int(st.session_state.get("max_output_tokens", 1024))
-
-                system_msg = {"role": "system", "content": "You are a helpful assistant that summarizes videos concisely in vivid detail."}
-                user_msg = {"role": "user", "content": prompt_text}
+                    uploaded = st.session_state["uploaded_file"]
+                    processed = st.session_state["processed_file"]
 
                 fname = file_name_or_id(processed) or file_name_or_id(uploaded)
-                response = call_responses_once(model_used, system_msg, user_msg, fname, max_tokens)
-
-                out = extract_text_from_response(response)
-
-                meta = getattr(response, "metrics", None) or (response.get("metrics") if isinstance(response, dict) else None) or {}
-                output_tokens = 0
-                try:
-                    if isinstance(meta, dict):
-                        output_tokens = int(meta.get("output_tokens", 0) or 0)
-                    else:
-                        output_tokens = int(getattr(meta, "output_tokens", 0) or 0)
-                except Exception:
-                    output_tokens = 0
-
-                if (not out or output_tokens == 0) and model_used:
-                    retry_prompt = "Summarize the video content briefly and vividly (2-4 paragraphs)."
-                    try:
-                        response2 = call_responses_once(model_used, system_msg, {"role": "user", "content": retry_prompt}, fname, min(max_tokens * 2, 4096))
-                        out2 = extract_text_from_response(response2)
-                        if out2 and len(out2) > len(out or ""):
-                            out = out2
-                        else:
-                            response3 = call_responses_once(model_used, system_msg, {"role": "user", "content": "List the main points of the video as 6-10 bullets."}, fname, min(1024, max_tokens * 2))
-                            out3 = extract_text_from_response(response3)
-                            if out3:
-                                out = out3
-                    except Exception:
-                        pass
-
+                resp = responses_generate_via_sdk(MODEL, prompt_text, fname, st.session_state.get("max_output_tokens", 1024))
+                out = extract_text(resp)
                 if out:
-                    out = remove_prompt_echo(prompt_text, out).strip()
-
+                    out = out.strip()
                 st.session_state["analysis_out"] = out or ""
                 st.session_state["last_error"] = ""
-
                 st.subheader("Analysis Result")
                 st.markdown(out or "_(no text returned)_")
-
-                try:
-                    if reupload_needed and compressed_path:
-                        p = Path(compressed_path)
-                        if p.exists():
-                            p.unlink(missing_ok=True)
-                except Exception:
-                    pass
-
-                with st.expander("Debug (compact)", expanded=False):
+                # cleanup compressed
+                if compressed:
                     try:
-                        info = {
-                            "model": model_used,
-                            "output_tokens": output_tokens,
-                            "upload_succeeded": bool(st.session_state.get("uploaded_file")),
-                            "processed_state": getattr(st.session_state.get("processed_file"), "state", None) if st.session_state.get("processed_file") else None,
-                        }
-                        st.write(info)
-                        try:
-                            if isinstance(response, dict):
-                                keys = list(response.keys())[:20]
-                            else:
-                                keys = [k for k in dir(response) if not k.startswith("_")][:20]
-                            st.write({"response_keys_or_attrs": keys})
-                        except Exception:
-                            pass
+                        Path(compressed).unlink(missing_ok=True)
                     except Exception:
-                        st.write("Debug info unavailable")
-
+                        pass
             except Exception as e:
                 st.session_state["last_error"] = str(e)
                 st.error(f"An error occurred while generating the story: {e}")
             finally:
                 st.session_state["busy"] = False
 
-# Show outputs / errors
 if st.session_state.get("analysis_out"):
     st.subheader("Analysis Result")
     st.markdown(st.session_state.get("analysis_out"))
 
 if st.session_state.get("last_error"):
-    with st.expander("Last Error", expanded=False):
+    with st.expander("Last Error"):
         st.write(st.session_state.get("last_error"))
 
-with st.sidebar.expander("Manage uploads", expanded=False):
-    if st.button("Delete uploaded files (local + cloud)"):
+with st.sidebar.expander("Manage uploads"):
+    if st.button("Delete local files"):
         for f in glob(str(DATA_DIR / "*")):
             try:
                 Path(f).unlink(missing_ok=True)
             except Exception:
                 pass
-        # attempt cloud deletion if supported
-        try:
-            fname = file_name_or_id(st.session_state.get("uploaded_file"))
-            if fname and delete_file and HAS_GENAI:
-                genai.configure(api_key=get_runtime_api_key() or os.getenv("GOOGLE_API_KEY", ""))
-                delete_file(fname)
-        except Exception:
-            pass
-        st.session_state["videos"] = ""
-        st.session_state["uploaded_file"] = None
-        st.session_state["processed_file"] = None
-        st.session_state["last_loaded_path"] = ""
-        st.session_state["analysis_out"] = ""
-        st.session_state["file_hash"] = None
-        st.success("Local files removed. Cloud deletion attempted where supported.")
+        st.session_state["video_path"] = ""
+        st.success("Local files removed")