Update streamlit_app.py

streamlit_app.py

@@ -3,6 +3,7 @@ import os
 import time
 import string
 import hashlib
+import traceback
 from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
@@ -352,143 +353,172 @@ if generate_now and not st.session_state.get("busy"):
                 est_tokens = max_tokens
                 est_cost_caption = f"Est. max tokens: {est_tokens}"
 
+                # First try Agent, but guard and FALLBACK to direct genai responses if Agent fails or returns empty.
                 agent = maybe_create_agent(model_used)
+                debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None, "agent_response_has_text": False}
                 if agent:
-                    with st.spinner("Generating description via Agent..."):
-                        if not processed:
-                            raise RuntimeError("Processed file missing for agent generation")
-                        response = agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
-                        out = getattr(response, "content", None) or getattr(response, "outputText", None) or str(response)
-                else:
-                    if not HAS_GENAI or genai is None:
-                        raise RuntimeError("Responses API not available; install google.generativeai SDK.")
-                    genai.configure(api_key=key_to_use)
-                    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."}
-
-                    # Try the modern and legacy signatures; fail clearly if both fail
+                    debug_info["agent_attempted"] = True
                     try:
-                        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 TypeError:
-                        response = genai.responses.generate(
-                            model=model_used,
-                            input=[{"text": prompt_text, "files": [{"name": fname}]}],
-                            safety_settings=safety_settings,
-                            max_output_tokens=max_tokens,
-                        )
-
-                    # Normalize response into iterable items safely
-                    outputs = []
-                    if response is None:
-                        outputs = []
-                    else:
-                        # response might be object or dict; try known attributes/keys
-                        if isinstance(response, dict):
-                            # common dict keys
-                            if isinstance(response.get("output"), list):
-                                outputs = response.get("output") or []
-                            elif isinstance(response.get("candidates"), list):
-                                outputs = response.get("candidates") or []
-                            elif isinstance(response.get("items"), list):
-                                outputs = response.get("items") or []
-                            elif isinstance(response.get("responses"), list):
-                                outputs = response.get("responses") or []
+                        with st.spinner("Generating description via Agent..."):
+                            if not processed:
+                                raise RuntimeError("Processed file missing for agent generation")
+                            # call agent.run inside try/except to catch library IndexError
+                            agent_response = agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
+                            # Try to extract text from common attributes; be defensive
+                            agent_text = getattr(agent_response, "content", None) or getattr(agent_response, "outputText", None) or None
+                            if not agent_text:
+                                # try dict-like access
+                                try:
+                                    if isinstance(agent_response, dict):
+                                        # check common keys
+                                        for k in ("content", "outputText", "text"):
+                                            if k in agent_response and agent_response[k]:
+                                                agent_text = agent_response[k]
+                                                break
+                                except Exception:
+                                    pass
+                            if agent_text and str(agent_text).strip():
+                                out = str(agent_text).strip()
+                                debug_info["agent_ok"] = True
+                                debug_info["agent_response_has_text"] = True
                             else:
-                                # fallback: try to find list-valued entries
+                                # Agent returned but had no usable text; set a marker to fallback
+                                debug_info["agent_ok"] = False
+                    except Exception as ae:
+                        # Save agent error and continue to fallback path instead of crashing
+                        debug_info["agent_error"] = f"{ae}"
+                        # include traceback for debugging
+                        debug_info["agent_traceback"] = traceback.format_exc()
+                        # Do not re-raise; we'll fallback to genai.responses.generate below
+
+                if not out:
+                    # Fallback to direct Responses API flow
+                    try:
+                        if not HAS_GENAI or genai is None:
+                            raise RuntimeError("Responses API not available; install google.generativeai SDK.")
+                        genai.configure(api_key=key_to_use)
+                        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."}
+
+                        try:
+                            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 TypeError:
+                            response = genai.responses.generate(
+                                model=model_used,
+                                input=[{"text": prompt_text, "files": [{"name": fname}]}],
+                                safety_settings=safety_settings,
+                                max_output_tokens=max_tokens,
+                            )
+
+                        # Defensive normalization of response -> outputs list
+                        outputs = []
+                        if response is None:
+                            outputs = []
+                        elif isinstance(response, dict):
+                            for key in ("output", "candidates", "items", "responses"):
+                                val = response.get(key)
+                                if isinstance(val, list) and val:
+                                    outputs = val
+                                    break
+                            if not outputs:
                                 for v in response.values():
-                                    if isinstance(v, list):
+                                    if isinstance(v, list) and v:
                                         outputs = v
                                         break
                         else:
-                            # try attribute access
-                            attr_candidates = []
                             for attr in ("output", "candidates", "items", "responses"):
                                 val = getattr(response, attr, None)
-                                if isinstance(val, list):
-                                    attr_candidates = val
+                                if isinstance(val, list) and val:
+                                    outputs = val
                                     break
-                            outputs = attr_candidates or []
-
-                    # Ensure we have a list
-                    if not isinstance(outputs, list):
-                        outputs = list(outputs) if outputs else []
-
-                    text_pieces = []
-                    # Iterate safely through outputs (may be dicts or objects)
-                    for item in outputs:
-                        if item is None:
-                            continue
-                        # attempt to extract a 'content' bag
-                        contents = None
-                        if isinstance(item, dict):
-                            contents = item.get("content") or item.get("text") or item.get("message") or item.get("output")
-                        else:
-                            contents = getattr(item, "content", None) or getattr(item, "text", None) or getattr(item, "message", None) or getattr(item, "output", None)
-
-                        # If contents is a single string, take it
-                        if isinstance(contents, str):
-                            if contents.strip():
-                                text_pieces.append(contents.strip())
-                            continue
-
-                        # If contents is list-like, iterate
-                        if isinstance(contents, (list, tuple)):
-                            for c in contents:
-                                if c is None:
-                                    continue
-                                if isinstance(c, str):
-                                    if c.strip():
-                                        text_pieces.append(c.strip())
-                                    continue
-                                c_text = None
-                                if isinstance(c, dict):
-                                    c_text = c.get("text") or c.get("content") or None
-                                else:
-                                    c_text = getattr(c, "text", None) or getattr(c, "content", None)
-                                if c_text:
-                                    text_pieces.append(str(c_text).strip())
-                            continue
-
-                        # If the item itself contains direct text fields
-                        direct_txt = None
-                        if isinstance(item, dict):
-                            direct_txt = item.get("text") or item.get("output_text") or item.get("message")
-                        else:
-                            direct_txt = getattr(item, "text", None) or getattr(item, "output_text", None) or getattr(item, "message", None)
-                        if direct_txt:
-                            text_pieces.append(str(direct_txt).strip())
-
-                    # final fallback: top-level text on response
-                    if not text_pieces:
-                        top_text = None
-                        if isinstance(response, dict):
-                            top_text = response.get("text") or response.get("message") or None
-                        else:
-                            top_text = getattr(response, "text", None) or getattr(response, "message", None)
-                        if top_text:
-                            text_pieces.append(str(top_text).strip())
-
-                    # dedupe preserving order
-                    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)
-                    out = "\n\n".join(filtered)
-
-                # post-process output to remove prompt echo or placeholders
+
+                        # ensure list
+                        if not isinstance(outputs, list):
+                            outputs = list(outputs) if outputs else []
+
+                        # extract text pieces safely
+                        text_pieces = []
+                        for item in outputs:
+                            if item is None:
+                                continue
+                            # item may be dict or object; attempt to find text-rich fields
+                            cand_contents = None
+                            if isinstance(item, dict):
+                                for k in ("content", "text", "message", "output_text", "output"):
+                                    if k in item and item[k]:
+                                        cand_contents = item[k]
+                                        break
+                            else:
+                                for k in ("content", "text", "message", "output", "output_text"):
+                                    cand_contents = getattr(item, k, None)
+                                    if cand_contents:
+                                        break
+
+                            if isinstance(cand_contents, str):
+                                if cand_contents.strip():
+                                    text_pieces.append(cand_contents.strip())
+                                continue
+
+                            if isinstance(cand_contents, (list, tuple)):
+                                for c in cand_contents:
+                                    if c is None:
+                                        continue
+                                    if isinstance(c, str):
+                                        if c.strip():
+                                            text_pieces.append(c.strip())
+                                        continue
+                                    if isinstance(c, dict):
+                                        t = c.get("text") or c.get("content")
+                                    else:
+                                        t = getattr(c, "text", None) or getattr(c, "content", None)
+                                    if t:
+                                        text_pieces.append(str(t).strip())
+                                continue
+
+                            direct = None
+                            if isinstance(item, dict):
+                                direct = item.get("text") or item.get("output_text") or item.get("message")
+                            else:
+                                direct = getattr(item, "text", None) or getattr(item, "output_text", None) or getattr(item, "message", None)
+                            if direct:
+                                text_pieces.append(str(direct).strip())
+
+                        if not text_pieces:
+                            top_text = None
+                            if isinstance(response, dict):
+                                top_text = response.get("text") or response.get("message")
+                            else:
+                                top_text = getattr(response, "text", None) or getattr(response, "message", None)
+                            if top_text:
+                                text_pieces.append(str(top_text).strip())
+
+                        # dedupe preserving order
+                        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)
+                        out = "\n\n".join(filtered)
+                    except Exception as e:
+                        # Capture clear error to UI and include debug_info
+                        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 = ""
+
+                # post-process output
                 if out:
                     out = remove_prompt_echo(prompt_text, out)
                     p = prompt_text
@@ -506,9 +536,11 @@ if generate_now and not st.session_state.get("busy"):
                 st.session_state["last_error"] = ""
                 st.subheader("Analysis Result")
                 st.markdown(out if out else "No analysis returned.")
-                st.caption(est_cost_caption)
+                st.caption(f"Est. max tokens: {est_tokens}")
+
             except Exception as e:
-                st.session_state["last_error"] = str(e)
+                tb = traceback.format_exc()
+                st.session_state["last_error"] = f"{e}\n\nDebug: {locals().get('debug_info', debug_info)}\n\nTraceback:\n{tb}"
                 st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
             finally:
                 st.session_state["busy"] = False