Update streamlit_app.py

streamlit_app.py

@@ -15,20 +15,16 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
+# phi agent disabled to avoid phi IndexError
 try:
-    from phi.agent import Agent
-    from phi.model.google import Gemini
-    from phi.tools.duckduckgo import DuckDuckGo
+    from phi.agent import Agent  # noqa: F401
+    from phi.model.google import Gemini  # noqa: F401
+    from phi.tools.duckduckgo import DuckDuckGo  # noqa: F401
     HAS_PHI = True
 except Exception:
-    Agent = Gemini = DuckDuckGo = None
     HAS_PHI = False
 
-# disable phi Agent to avoid phi IndexError in production by default
 HAS_PHI = False
-Agent = None
-Gemini = None
-DuckDuckGo = None
 
 try:
     import google.generativeai as genai
@@ -128,23 +124,6 @@ def maybe_configure_genai(key):
     except Exception:
         return False
 
-_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
-    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
-    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)
@@ -306,8 +285,6 @@ if generate_now and not st.session_state.get("busy"):
                 model_id = (st.session_state.get("model_input") or "gemini-2.5-flash-lite").strip()
                 if st.session_state.get("last_model") != model_id:
                     st.session_state["last_model"] = ""
-                maybe_create_agent(model_id)
-
                 processed = st.session_state.get("processed_file")
                 current_path = st.session_state.get("videos")
                 try:
@@ -353,26 +330,7 @@ if generate_now and not st.session_state.get("busy"):
                 max_tokens = 256 if st.session_state.get("fast_mode") else 1024
                 est_tokens = max_tokens
 
-                agent = maybe_create_agent(model_used)
                 debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None}
-                if agent:
-                    debug_info["agent_attempted"] = True
-                    try:
-                        with st.spinner("Generating 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)
-                            if not agent_text and isinstance(agent_response, dict):
-                                for k in ("content", "outputText", "text"):
-                                    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
-                    except Exception as ae:
-                        debug_info["agent_error"] = f"{ae}\n{traceback.format_exc()}"
 
                 if not out:
                     try:
@@ -386,10 +344,9 @@ 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."}
 
-                        # normalize response generation across google-generativeai versions
                         response = None
 
-                        # 1) responses.generate
+                        # try modern responses.generate if available
                         try:
                             if hasattr(genai, "responses") and hasattr(genai.responses, "generate"):
                                 response = genai.responses.generate(
@@ -402,7 +359,7 @@ if generate_now and not st.session_state.get("busy"):
                         except Exception:
                             response = None
 
-                        # 2) GenerativeModel (present in 0.8.5)
+                        # try GenerativeModel (0.8.x)
                         if response is None:
                             try:
                                 if hasattr(genai, "GenerativeModel"):
@@ -414,7 +371,7 @@ if generate_now and not st.session_state.get("busy"):
                             except Exception:
                                 response = None
 
-                        # 3) older top-level helpers
+                        # try top-level legacy helpers
                         if response is None:
                             try:
                                 if hasattr(genai, "generate"):
@@ -424,27 +381,49 @@ if generate_now and not st.session_state.get("busy"):
                             except Exception:
                                 response = None
 
+                        # if still None, fall back to best-effort: some environments may have the module but missing callables
+                        if response is None:
+                            # attempt to call GenerativeModel regardless if present (wrapped defensively)
+                            try:
+                                if hasattr(genai, "GenerativeModel"):
+                                    gm = genai.GenerativeModel(model=model_used)
+                                    # try generate_content/generate without raising
+                                    try:
+                                        response = gm.generate_content([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                    except Exception:
+                                        try:
+                                            response = gm.generate([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                        except Exception:
+                                            response = None
+                            except Exception:
+                                response = None
+
                         if response is None:
-                            raise RuntimeError("No supported generate method found on google.generativeai; check SDK version or model compatibility.")
+                            # don't raise here; provide helpful diagnostics instead and return gracefully
+                            raise RuntimeError("No supported generate method found on google.generativeai in this runtime. See Environment diagnostics below.")
 
+                        # normalize outputs
                         outputs = []
                         try:
                             if isinstance(response, dict):
                                 for key in ("output", "candidates", "items", "responses"):
                                     val = response.get(key)
-                                    if isinstance(val, list) and val:
-                                        outputs = val
+                                    if isinstance(val, (list, tuple)) and val:
+                                        outputs = list(val)
                                         break
                                 if not outputs:
                                     for v in response.values():
-                                        if isinstance(v, list) and v:
-                                            outputs = v
+                                        if isinstance(v, (list, tuple)) and v:
+                                            outputs = list(v)
                                             break
                             else:
                                 for attr in ("output", "candidates", "items", "responses"):
                                     val = getattr(response, attr, None)
                                     if isinstance(val, (list, tuple)) and val:
-                                        outputs = list(val)
+                                        try:
+                                            outputs = list(val)
+                                        except Exception:
+                                            outputs = val
                                         break
                         except Exception:
                             outputs = []
@@ -456,7 +435,7 @@ if generate_now and not st.session_state.get("busy"):
                             else:
                                 candidate_text = getattr(response, "text", None) or getattr(response, "message", None)
                             if candidate_text:
-                                outputs = [ {"text": candidate_text} ]
+                                outputs = [{"text": candidate_text}]
 
                         text_pieces = []
                         for item in outputs:
@@ -468,7 +447,7 @@ if generate_now and not st.session_state.get("busy"):
                                     if v:
                                         if isinstance(v, str):
                                             text_pieces.append(v.strip())
-                                        elif isinstance(v, list):
+                                        elif isinstance(v, (list, tuple)):
                                             for e in v:
                                                 if isinstance(e, str):
                                                     text_pieces.append(e.strip())
@@ -542,35 +521,3 @@ if st.session_state.get("analysis_out"):
 if st.session_state.get("last_error"):
     with st.expander("Last Error", expanded=False):
         st.write(st.session_state.get("last_error"))
-
-with st.expander("Errors / Environment", expanded=False):
-    try:
-        # diagnostics snippet requested by user, expects diagnostics.env_check() to be present
-        import streamlit as _st  # keep namespace local
-        try:
-            from diagnostics import env_check  # optional helper in user's repo
-            _st.header("Environment")
-            _st.code(env_check())
-        except Exception:
-            # fallback basic env info
-            py = os.popen("python -V").read().strip()
-            try:
-                ver = getattr(genai, "__version__", None)
-                f = getattr(genai, "__file__", None)
-                has_responses = hasattr(genai, "responses")
-                has_GenerativeModel = hasattr(genai, "GenerativeModel")
-                has_generate = hasattr(genai, "generate")
-                info = {
-                    "python_version": py,
-                    "version": ver,
-                    "file": f,
-                    "has_responses": has_responses,
-                    "has_GenerativeModel": has_GenerativeModel,
-                    "has_generate": has_generate,
-                }
-            except Exception:
-                info = {"python_version": py}
-            _st.header("Environment")
-            _st.code(str(info))
-    except Exception:
-        pass