Update streamlit_app.py

streamlit_app.py

@@ -1,9 +1,11 @@
 # streamlit_app.py
+
 import os
 import time
 import string
 import hashlib
 import traceback
+import base64
 from glob import glob
 from pathlib import Path
 
@@ -28,13 +30,9 @@ except Exception:
 # google.generativeai SDK (guarded)
 try:
     import google.generativeai as genai
-    # older SDK exposed upload_file/get_file at top-level; try to bind them if present
-    upload_file = getattr(genai, "upload_file", None)
-    get_file = getattr(genai, "get_file", None)
     HAS_GENAI = True
 except Exception:
     genai = None
-    upload_file = get_file = None
     HAS_GENAI = False
 
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
@@ -147,84 +145,109 @@ def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) ->
     final = convert_video_to_mp4(chosen)
     return final
 
-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") or file_obj.get("fileId")
-    # SDK objects might expose .name, .id, .fileId, or nested fields
-    for attr in ("name", "id", "fileId", "file_id"):
-        v = getattr(file_obj, attr, None)
-        if v:
-            return v
-    # sometimes SDK returns {'file': {...}}
+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())
     try:
-        if hasattr(file_obj, "to_dict"):
-            d = file_obj.to_dict()
-            if isinstance(d, dict):
-                return d.get("name") or d.get("id") or d.get("fileId")
+        from difflib import SequenceMatcher
+        ratio = SequenceMatcher(None, a, b).ratio()
     except Exception:
-        pass
-    return None
+        ratio = 0.0
+    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:
+        st.session_state["last_error"] = "Failed to stat file before compression"
+        return local_path, False
+
+    if file_size_mb <= threshold_mb:
+        return local_path, False
 
-def get_effective_api_key():
-    return st.session_state.get("api_key") or os.getenv("GOOGLE_API_KEY")
+    p = Path(local_path)
+    compressed_name = f"{p.stem}_compressed.mp4"
+    compressed_path = str(p.with_name(compressed_name))
 
-def configure_genai_if_needed():
-    key = get_effective_api_key()
-    if not key:
-        return False
     try:
-        genai.configure(api_key=key)
+        result = compress_video(local_path, compressed_path, crf=28, preset="fast")
+        if result and os.path.exists(result) and os.path.getsize(result) > 0:
+            return result, True
+        return local_path, False
     except Exception:
-        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
+        st.session_state["last_error"] = "Video compression failed"
+        return local_path, False
+
+# ---- Inline-video generation via base64 (bypass upload) ----
+def generate_with_inline_video(local_path: str, prompt: str, model_used: str, timeout: int = 300):
+    # Read the video bytes
+    with open(local_path, "rb") as f:
+        video_bytes = f.read()
+    b64 = base64.b64encode(video_bytes).decode("utf-8")
+    video_part = {
+        "inline_data": {
+            "mime_type": "video/mp4",
+            "data": b64
+        }
+    }
+    contents = [prompt, video_part]
+
+    # Use new client API if present
     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
+        client = genai.Client()
+        resp = client.models.generate_content(
+            model=model_used,
+            contents=contents,
+            generation_config={"max_output_tokens": 1024}
+        )
     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_local_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
+        # Fallback older style
+        resp = genai.GenerativeModel(model_used).generate_content(contents)
+
+    text = getattr(resp, "text", None) or getattr(resp, "output_text", None) or str(resp)
+    return text
+
+# ---- Main UI & logic ----
 
 # Reset when URL changes (compare against last_url only)
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url"):
     if st.session_state.get("last_url"):
-        clear_all_video_state()
+        # clear old video state
+        st.session_state.pop("uploaded_file", None)
+        st.session_state.pop("processed_file", None)
+        st.session_state["videos"] = ""
+        st.session_state["last_local_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
     st.session_state["last_url"] = current_url
 
-# ---- Sidebar UI ----
+# 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)
+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
@@ -254,191 +277,13 @@ settings_exp.number_input(
 
 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_with_kwargs(fn, filepath):
-    """
-    Call an upload function `fn` with the required ragStoreName argument.
-    Most recent google.generativeai SDK versions expect:
-        upload_file(path, ragStoreName="default")
-    Older versions accept just the path, so we try both signatures.
-    """
-    try:
-        # Preferred modern signature
-        return fn(filepath, ragStoreName="default")
-    except TypeError:
-        # Fallback to older signature (no ragStoreName)
-        return fn(filepath)
-    except Exception as e:
-        # Propagate any other error for higher‑level handling
-        raise e
-
-
-def upload_video_sdk(filepath: str):
-    """Upload a video file using whichever upload function the SDK provides."""
-    key = get_effective_api_key()
-    if not key:
-        raise RuntimeError("No API key provided")
-    if not HAS_GENAI or genai is None:
-        raise RuntimeError("google.generativeai SDK not available; cannot upload")
-
-    genai.configure(api_key=key)
-
-    # Build a list of possible upload callables (newest first)
-    candidate_calls = []
-
-    # Newer SDK exposes upload_file directly
-    if upload_file:
-        candidate_calls.append(("upload_file", upload_file))
-
-    # Some installations expose it under ragstore or files namespaces
-    candidate_calls.append(
-        ("genai.ragstore.upload_file",
-         getattr(genai, "ragstore", None) and getattr(genai.ragstore, "upload_file", None))
-    )
-    candidate_calls.append(
-        ("genai.files.upload",
-         getattr(genai, "files", None) and getattr(genai.files, "upload", None))
-    )
-    candidate_calls.append(
-        ("genai.upload",
-         getattr(genai, "upload", None))
-    )
-
-    # Filter out any None entries
-    candidate_calls = [(name, fn) for name, fn in candidate_calls if fn]
-
-    if not candidate_calls:
-        raise RuntimeError("No upload function available in google.generativeai SDK")
-
-    last_exc = None
-    for name, fn in candidate_calls:
-        try:
-            # Use the wrapper that injects ragStoreName when needed
-            res = _upload_with_kwargs(fn, filepath)
-            # Normalise the return value so the rest of the code works
-            return _normalize_uploaded_obj(res)
-        except Exception as e:
-            last_exc = e
-            # Log the attempted method for debugging (optional)
-            st.session_state["last_error"] = f"Upload attempt '{name}' failed: {e}"
-            continue
-
-    # If we get here every method failed
-    raise RuntimeError(f"All upload methods failed. Last error: {last_exc}")
-
-def wait_for_processed(file_obj, timeout: int = None):
-    if timeout is None:
-        timeout = st.session_state.get("processing_timeout", 900)
-    if not HAS_GENAI or genai is None:
-        return file_obj
-    start = time.time()
-    name = file_name_or_id(file_obj)
-    # If no determinable name/id, just return file_obj
-    if not name:
-        return file_obj
-    genai.configure(api_key=get_effective_api_key())
-    backoff = 1.0
-    last_exc = None
-    # prefer get_file if present, otherwise try genai.ragstore.get or genai.files.get
-    candidate_getters = []
-    if get_file:
-        candidate_getters.append(("get_file", get_file))
-    candidate_getters.append(("genai.ragstore.get", getattr(genai, "ragstore", None) and getattr(genai.ragstore, "get", None)))
-    candidate_getters.append(("genai.files.get", getattr(genai, "files", None) and getattr(genai.files, "get", None)))
-    candidate_getters = [(n, fn) for n, fn in candidate_getters if fn]
-    # If none, return file_obj immediately
-    if not candidate_getters:
-        return file_obj
-
-    while True:
-        for name_label, getter in candidate_getters:
-            try:
-                obj = getter(name)
-                # normalize possible SDK object/dict
-                # check for state attribute or dict field
-                state = None
-                if isinstance(obj, dict):
-                    state = obj.get("state") or (obj.get("status") and {"name": obj.get("status")})
-                else:
-                    state = getattr(obj, "state", None) or getattr(obj, "status", None)
-                if not state:
-                    return obj
-                # state might be dict or object with .name
-                state_name = state.get("name") if isinstance(state, dict) else getattr(state, "name", None)
-                if state_name and state_name.upper() == "PROCESSING":
-                    # still processing; continue polling
-                    last_obj = obj
-                    break
-                return obj
-            except Exception as e:
-                last_exc = e
-                # transient errors: backoff and retry until timeout
-                continue
-        if time.time() - start > timeout:
-            raise TimeoutError(f"File processing timed out. 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())
-    try:
-        from difflib import SequenceMatcher
-        ratio = SequenceMatcher(None, a, b).ratio()
-    except Exception:
-        ratio = 0.0
-    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:
-        st.session_state["last_error"] = "Failed to stat file before compression"
-        return local_path, False
-
-    if file_size_mb <= threshold_mb:
-        return local_path, False
-
-    p = Path(local_path)
-    compressed_name = f"{p.stem}_compressed.mp4"
-    compressed_path = str(p.with_name(compressed_name))
-
-    try:
-        result = compress_video(local_path, compressed_path, crf=28, preset="fast")
-        if result and os.path.exists(result) and os.path.getsize(result) > 0:
-            return result, True
-        return local_path, False
-    except Exception:
-        st.session_state["last_error"] = "Video compression failed"
-        return local_path, False
+if not st.session_state.get("api_key") and not os.getenv("GOOGLE_API_KEY"):
+    settings_exp.warning("No Google API key provided; generation disabled.", icon="⚠️")
 
-# ---- Simple layout ----
+# Buttons & 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()))
+    generate_now = st.button("Generate the story", type="primary")
 with col2:
     if not st.session_state.get("videos"):
         st.info("Load a video first (sidebar) to enable generation.", icon="ℹ️")
@@ -453,10 +298,7 @@ if st.sidebar.button("Load Video", use_container_width=True):
         st.session_state["last_local_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)
     except Exception as e:
         st.sidebar.error(f"Failed to load video: {e}")
 
@@ -475,11 +317,25 @@ if st.session_state["videos"]:
         st.session_state["loop_video"] = loop_checkbox
 
         if st.button("Clear Video(s)"):
-            clear_all_video_state()
+            # Clear video state
+            st.session_state.pop("uploaded_file", None)
+            st.session_state.pop("processed_file", None)
+            st.session_state["videos"] = ""
+            st.session_state["last_local_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
 
         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)
+                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")
 
@@ -488,226 +344,41 @@ if st.session_state["videos"]:
         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("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="⚠️")
+            st.sidebar.warning(
+                f"Large file detected — it may exceed inline size limits (>{st.session_state.get('compress_threshold_mb')} MB).",
+                icon="⚠️"
+            )
     except Exception:
         pass
 
-# ---- Generation flow (fixed and robust) ----
+# Generation / analysis
 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.")
     else:
-        key_to_use = get_effective_api_key()
-        if not key_to_use:
+        key = st.session_state.get("api_key") or os.getenv("GOOGLE_API_KEY")
+        if not key:
             st.error("Google API key not set.")
         else:
+            st.session_state["busy"] = True
             try:
-                st.session_state["busy"] = True
-                try:
-                    if HAS_GENAI and genai is not None:
-                        genai.configure(api_key=key_to_use)
-                except Exception:
-                    pass
-
+                genai.configure(api_key=key)
                 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")
-                try:
-                    current_hash = file_sha256(current_path) if current_path and os.path.exists(current_path) else None
-                except Exception:
-                    current_hash = None
-
-                reupload_needed = True
-                uploaded_file = st.session_state.get("uploaded_file")
-                uploaded_name = file_name_or_id(uploaded_file)
-                if processed and st.session_state.get("last_local_path") == current_path and st.session_state.get("file_hash") == current_hash and uploaded_name:
-                    reupload_needed = False
-
-                if reupload_needed:
-                    if not HAS_GENAI:
-                        raise RuntimeError("google.generativeai SDK not available; install it.")
-                    local_path = current_path
-                    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 ''}..."):
-                        try:
-                            uploaded = upload_video_sdk(upload_path)
-                        except Exception as e:
-                            st.session_state["last_error"] = f"Upload failed for {upload_path}: {e}\n{traceback.format_exc()}"
-                            st.error(f"Upload failed: {e}. Check the error log for more details.")
-                            st.session_state["busy"] = False
-                            raise
-
-                    try:
-                        processing_placeholder = st.empty()
-                        processing_bar = processing_placeholder.progress(0)
-                        start_time = time.time()
-                        processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 900))
-                        elapsed = time.time() - start_time
-                        timeout = st.session_state.get("processing_timeout", 900)
-                        pct = min(100, int((elapsed / timeout) * 100)) if timeout > 0 else 0
-                        processing_bar.progress(pct)
-                        processing_placeholder.success("Processing complete")
-                    except Exception as e:
-                        st.session_state["last_error"] = f"Processing failed/wait timeout: {e}"
-                        st.error("Video processing failed or timed out. See Last Error.")
-                        st.session_state["busy"] = False
-                        raise
-
-                    st.session_state["uploaded_file"] = uploaded
-                    st.session_state["processed_file"] = processed
-                    st.session_state["last_local_path"] = current_path
-                    st.session_state["file_hash"] = current_hash
-
                 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 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:
-                                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
-                            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}"
-
-                if not out:
-                    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")
-                        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."}
-
-                        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")):
-                                        continue
-                                    raise
-                            if time.time() - start > timeout:
-                                raise TimeoutError("Responses.generate timed out")
-                            time.sleep(backoff)
-                            backoff = min(backoff * 2, 8.0)
-
-                    def _normalize_genai_response(response):
-                        outputs = []
-                        if response is None:
-                            return ""
-                        text_pieces = []
-                        try:
-                            if isinstance(response, dict):
-                                for key in ("output", "candidates", "items", "responses", "choices"):
-                                    val = response.get(key)
-                                    if isinstance(val, list) and val:
-                                        for item in val:
-                                            if isinstance(item, dict):
-                                                for k in ("content", "text", "message", "output_text", "output"):
-                                                    t = item.get(k)
-                                                    if t:
-                                                        text_pieces.append(str(t).strip())
-                                                        break
-                                            elif isinstance(item, str):
-                                                text_pieces.append(item.strip())
-                                if not text_pieces:
-                                    for k in ("text", "message", "output_text"):
-                                        v = response.get(k)
-                                        if v:
-                                            text_pieces.append(str(v).strip())
-                                            break
-                            else:
-                                # SDK object: try attributes
-                                for attr in ("output", "candidates", "text", "message", "content"):
-                                    v = getattr(response, attr, None)
-                                    if v:
-                                        text_pieces.append(str(v).strip())
-                            if not text_pieces:
-                                text_pieces.append(str(response))
-                        except Exception:
-                            text_pieces.append(str(response))
-                        seen = set()
-                        filtered = []
-                        for t in text_pieces:
-                            if not isinstance(t, str):
-                                continue
-                            if t and t not in seen:
-                                filtered.append(t)
-                                seen.add(t)
-                        return "\n\n".join(filtered).strip()
-
-                    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:
-                        st.session_state["last_error"] = f"Responses API error: {e}\nDebug: {debug_info}"
-                        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:-")
-                    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()
 
+                with st.spinner("Generating analysis (inline video)…"):
+                    out = generate_with_inline_video(
+                        st.session_state["videos"], prompt_text, model_id,
+                        timeout=st.session_state.get("generation_timeout", 300)
+                    )
+
+                out = remove_prompt_echo(prompt_text, out)
                 st.session_state["analysis_out"] = out
                 st.session_state["last_error"] = ""
                 st.subheader("Analysis Result")
-                st.markdown(out if out else "No analysis returned.")
-                st.caption(f"Est. max tokens: {est_tokens}")
-
+                st.markdown(out or "No analysis returned.")
             except Exception as e:
-                st.session_state["last_error"] = f"{e}\n{traceback.format_exc()}"
-                st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
+                st.session_state["last_error"] = f"Inline generation error: {e}\n{traceback.format_exc()}"
+                st.error("An error occurred while generating the story using inline video. Check the error log.")
             finally:
                 st.session_state["busy"] = False