Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,3 @@
-# streamlit_app.py
 import os
 import time
 import hashlib
@@ -216,7 +215,7 @@ 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", help="Provide only if you want uploads/generation. Not stored in session.")
+API_KEY_INPUT = settings.text_input("Google API Key (one-time)", value="", type="password")
 model_input = settings.text_input("Gemini Model (short name)", "gemini-2.0-flash-lite")
 model_id = model_input.strip() or "gemini-2.0-flash-lite"
 model_arg = model_id if not model_id.startswith("models/") else model_id.split("/", 1)[1]
@@ -236,7 +235,7 @@ settings.checkbox("Enable compression for large files (>50MB)", value=True, key=
 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. Use local-only demos or provide key for real analysis.", icon="ℹ️")
+    settings.info("No Google API key provided; upload/generation disabled.", icon="ℹ️")
 
 if st.sidebar.button("Load Video", use_container_width=True):
     try:
@@ -298,33 +297,38 @@ def get_runtime_api_key():
         return key
     return os.getenv("GOOGLE_API_KEY", "").strip() or None
 
-# Responses caller supporting SDK variants and HTTP fallback
+# Robust responses caller: SDK preferred, then attempt HTTP fallback via requests
 def responses_generate(model, messages, files, max_output_tokens, api_key):
+    if not api_key:
+        raise RuntimeError("No API key for responses_generate")
+    if not HAS_GENAI:
+        # try HTTP directly using requests
+        import requests
+        url = "https://gen-ai.googleapis.com/v1/responses"
+        payload = {"model": model, "messages": messages, "max_output_tokens": max_output_tokens}
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        try:
+            r = requests.post(url, json=payload, headers=headers, timeout=60)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            raise RuntimeError(f"HTTP fallback to Responses API failed: {e}")
     genai.configure(api_key=api_key)
-    # preferred SDK style
+    # preferred SDK call
     if hasattr(genai, "responses") and getattr(genai, "responses") is not None:
-        try:
-            return genai.responses.generate(model=model, messages=messages, files=files, max_output_tokens=max_output_tokens)
-        except Exception:
-            # let higher level handle retries/errors
-            raise
-    # older/newer SDKs might expose different helpers; attempt generic client POST
-    # fallback: directly call the REST endpoint via genai.client/_client if available
+        return genai.responses.generate(model=model, messages=messages, files=files, max_output_tokens=max_output_tokens)
+    # try client-level post if exposed
     client_attr = getattr(genai, "client", None) or getattr(genai, "_client", None) or getattr(genai, "transport", None)
     if client_attr:
-        try:
-            # construct payload similar to Responses API
+        post = getattr(client_attr, "post", None) or getattr(client_attr, "request", None)
+        if post:
             payload = {"model": model, "messages": messages, "max_output_tokens": max_output_tokens}
             headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-            # try to find a requests-like post method
-            post = getattr(client_attr, "post", None) or getattr(client_attr, "request", None)
-            if post:
-                # endpoint path used by Google Generative API
-                url = "/v1/responses"
-                resp = post(url, json=payload, headers=headers)
+            try:
+                resp = post("/v1/responses", json=payload, headers=headers)
                 return resp
-        except Exception:
-            pass
+            except Exception:
+                pass
     raise RuntimeError("genai.responses not available and HTTP fallback failed")
 
 if (st.session_state.get("busy") is False) and ('generate_now' in locals() and generate_now):
@@ -334,8 +338,6 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
         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.")
-        elif not HAS_GENAI:
-            st.error("google.generativeai SDK not available. Install the SDK to enable uploads/generation.")
         else:
             try:
                 st.session_state["busy"] = True
@@ -369,14 +371,21 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                         except Exception:
                             upload_path = local_path
 
-                    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
+                    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:
+                        # no SDK upload support: continue without upload and try HTTP responses with no file reference
+                        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")
@@ -395,7 +404,8 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                 def call_responses_once(model_used, system_msg, user_msg, fname, max_tokens):
                     for attempt in range(2):
                         try:
-                            resp = responses_generate(model_used, [system_msg, user_msg], [{"name": fname}], max_tokens, api_key=runtime_key)
+                            files = [{"name": fname}] if fname else None
+                            resp = responses_generate(model_used, [system_msg, user_msg], files, max_tokens, api_key=runtime_key)
                             return resp
                         except Exception:
                             if attempt == 0:
@@ -404,26 +414,17 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                             raise
 
                 fname = file_name_or_id(processed) or file_name_or_id(uploaded)
-                if not fname:
-                    try:
-                        uri = getattr(processed, "uri", None) or (processed.get("uri") if isinstance(processed, dict) else None)
-                        if uri:
-                            tail = str(uri).rstrip("/").split("/")[-1]
-                            fname = tail if tail.startswith("files/") else f"files/{tail}"
-                    except Exception:
-                        pass
-                if not fname:
-                    raise RuntimeError("Uploaded file missing name/id/uri; cannot reference for Responses API.")
-
                 response = call_responses_once(model_used, system_msg, user_msg, fname, max_tokens)
 
                 def extract_text_from_response(response):
                     outputs = getattr(response, "output", None) or (response.get("output") if isinstance(response, dict) else None) or []
-                    if not outputs and isinstance(response, dict):
-                        outputs = response.get("output", [])
+                    if isinstance(outputs, dict):
+                        outputs = outputs.get("contents") or outputs.get("items") or []
                     text_pieces = []
                     for item in outputs or []:
                         contents = getattr(item, "content", None) or (item.get("content") if isinstance(item, dict) else None) or []
+                        if isinstance(contents, dict):
+                            contents = [contents]
                         for c in contents:
                             ctype = getattr(c, "type", None) or (c.get("type") if isinstance(c, dict) else None)
                             if ctype in ("output_text", "text") or ctype is None: