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
@@ -353,6 +354,7 @@ if generate_now and not st.session_state.get("busy"):
                 est_cost_caption = f"Est. max tokens: {est_tokens}"
 
                 agent = maybe_create_agent(model_used)
+                debug_info = {"response_shape": None, "outputs_len": None, "outputs_types": None}
                 if agent:
                     with st.spinner("Generating description via Agent..."):
                         if not processed:
@@ -369,7 +371,6 @@ if generate_now and not st.session_state.get("busy"):
                     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
                     try:
                         response = genai.responses.generate(
                             model=model_used,
@@ -386,92 +387,100 @@ if generate_now and not st.session_state.get("busy"):
                             max_output_tokens=max_tokens,
                         )
 
-                    # Normalize response into iterable items safely
+                    # record raw shape for debugging
+                    debug_info["response_shape"] = type(response).__name__ if response is not None else "None"
+
+                    # SAFE normalization into list
                     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 []
-                            else:
-                                # fallback: try to find list-valued entries
+                    try:
+                        if response is None:
+                            outputs = []
+                        elif isinstance(response, dict):
+                            # typical dict shapes
+                            for key in ("output", "candidates", "items", "responses"):
+                                val = response.get(key)
+                                if isinstance(val, list) and val:
+                                    outputs = val
+                                    break
+                            if not outputs:
+                                # pick first list-valued entry if any
                                 for v in response.values():
                                     if isinstance(v, list):
                                         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 []
+                    except Exception as e:
+                        # unexpected structure -> capture for debug and continue with empty outputs
+                        st.session_state["last_error"] = f"Response parsing error: {e}\n{traceback.format_exc()}"
+                        outputs = []
 
-                    # Ensure we have a list
-                    if not isinstance(outputs, list):
-                        outputs = list(outputs) if outputs else []
+                    debug_info["outputs_len"] = len(outputs)
+                    debug_info["outputs_types"] = [type(o).__name__ for o in outputs]
 
+                    # iterate without indexing
                     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
+                    try:
+                        for item in outputs:
+                            if item is None:
+                                continue
+                            # get potential content container(s)
+                            cand_contents = None
+                            if isinstance(item, dict):
+                                # common keys that may hold text
+                                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 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())
+                            # handle string content
+                            if isinstance(cand_contents, str):
+                                if cand_contents.strip():
+                                    text_pieces.append(cand_contents.strip())
+                                continue
+
+                            # handle list-like content
+                            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
+
+                            # fallback to direct text on item
+                            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())
+                    except Exception as e:
+                        st.session_state["last_error"] = f"Error while extracting text pieces: {e}\n{traceback.format_exc()}"
 
-                    # final fallback: top-level text on response
+                    # last resort: top-level text
                     if not text_pieces:
                         top_text = None
                         if isinstance(response, dict):
-                            top_text = response.get("text") or response.get("message") or None
+                            top_text = response.get("text") or response.get("message")
                         else:
                             top_text = getattr(response, "text", None) or getattr(response, "message", None)
                         if top_text:
@@ -507,18 +516,34 @@ if generate_now and not st.session_state.get("busy"):
                 st.subheader("Analysis Result")
                 st.markdown(out if out else "No analysis returned.")
                 st.caption(est_cost_caption)
+
             except Exception as e:
-                st.session_state["last_error"] = str(e)
+                # Build improved error info to display in the UI
+                tb = traceback.format_exc()
+                # If we have debug_info, include it
+                dbg = locals().get("debug_info") or {}
+                # Save a concise message + trace to last_error so UI shows it
+                st.session_state["last_error"] = f"{str(e)}\n\nDebug: {dbg}\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
 
+# show analysis if present
 if st.session_state.get("analysis_out"):
     just_loaded_same = (st.session_state.get("last_loaded_path") == st.session_state.get("videos"))
     if not just_loaded_same:
         st.subheader("Analysis Result")
         st.markdown(st.session_state.get("analysis_out"))
 
+# show last error and debug helper
 if st.session_state.get("last_error"):
-    with st.expander("Last Error", expanded=False):
+    with st.expander("Last Error (click to expand)", expanded=True):
         st.write(st.session_state.get("last_error"))
+        # If we extracted debug_info earlier, show short diagnostics
+        try:
+            di = locals().get("debug_info") or {}
+            if di:
+                st.write("Debug info (if available):")
+                st.write(di)
+        except Exception:
+            pass