Update streamlit_app.py

streamlit_app.py

@@ -4,6 +4,7 @@ import time
 import string
 import hashlib
 import traceback
+import inspect
 from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
@@ -18,13 +19,18 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-# phi agent removed to avoid fragile imports in varied environments
+# Remove phi agent code (fragile imports); keep simple flag
 HAS_PHI = False
 
 # google generative ai SDK (may be absent or partial in some runtimes)
 try:
     import google.generativeai as genai  # type: ignore
-    from google.generativeai import upload_file, get_file  # type: ignore
+    # upload_file/get_file exist in some versions
+    try:
+        from google.generativeai import upload_file, get_file  # type: ignore
+    except Exception:
+        upload_file = None
+        get_file = None
     HAS_GENAI = True
 except Exception:
     genai = None
@@ -117,7 +123,6 @@ def maybe_configure_genai(key):
     if not key or not HAS_GENAI:
         return False
     try:
-        # defensive configuration (some envs require configure)
         genai.configure(api_key=key)
         return True
     except Exception:
@@ -137,7 +142,7 @@ def clear_all_video_state():
         except Exception:
             pass
 
-# URL expand + extraction helpers (integrated into Load Video)
+# URL expand + extraction helpers
 def expand_url(short_url, timeout=10):
     try:
         r = requests.get(short_url, allow_redirects=True, timeout=timeout, headers={"User-Agent":"Mozilla/5.0"})
@@ -148,50 +153,41 @@ def expand_url(short_url, timeout=10):
 
 def extract_video_from_html(html, base_url=None):
     soup = BeautifulSoup(html, "html.parser")
-    # 1) Open Graph video
     og = soup.find("meta", property="og:video")
     if og and og.get("content"):
         return og.get("content")
-    # 2) Look for video tags
     vtag = soup.find("video")
     if vtag:
         src = vtag.get("src")
         if src:
             return src
-        # source children
         source = vtag.find("source")
         if source and source.get("src"):
             return source.get("src")
-    # 3) JSON-LD or structured data with video
     for script in soup.find_all("script", type="application/ld+json"):
         try:
             import json
             data = json.loads(script.string or "{}")
-            # common pattern
             if isinstance(data, dict):
                 video = data.get("video") or data.get("videoObject") or data.get("mainEntity")
                 if isinstance(video, dict):
                     for k in ("contentUrl", "url"):
                         if video.get(k):
                             return video.get(k)
-                # top-level contentUrl
                 if data.get("contentUrl"):
                     return data.get("contentUrl")
         except Exception:
             continue
-    # 4) look for meta property site-specific fallbacks
     for meta_name in ("twitter:player:stream", "twitter:player"):
         m = soup.find("meta", attrs={"name": meta_name})
         if m and m.get("content"):
             return m.get("content")
-    # fallback: search for direct links to common video hosts (youtube, vimeo) in anchor tags
     for a in soup.find_all("a", href=True):
         href = a["href"]
         if any(domain in href for domain in ("youtube.com", "youtu.be", "vimeo.com")):
             return href
     return None
 
-# When SDK has upload_file/get_file, use them; else raise when needed
 def upload_video_sdk(filepath: str):
     key = get_effective_api_key()
     if not key:
@@ -244,6 +240,86 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
             return b_full[len(ph):].lstrip(" \n:-")
     return text
 
+# Helper: try to call GenerativeModel with compatible signature
+def generative_model_call_flexible(model_name, messages, files=None, max_output_tokens=1024):
+    """
+    Try different call patterns for genai.GenerativeModel depending on its constructor/signature.
+    Returns the response object or raises if none work.
+    """
+    if not HAS_GENAI or genai is None:
+        raise RuntimeError("genai not available")
+
+    # Inspect GenerativeModel if present
+    GM = getattr(genai, "GenerativeModel", None)
+    if GM is None:
+        raise RuntimeError("GenerativeModel not available")
+
+    # Inspect constructor signature
+    try:
+        sig = inspect.signature(GM)
+        params = sig.parameters
+        # prefer 'model' if available
+        if "model" in params:
+            gm = GM(model=model_name)
+        elif "model_name" in params:
+            gm = GM(model_name=model_name)
+        else:
+            # fallback to no-arg constructor
+            gm = GM()
+            # attempt to set attribute if accepted
+            try:
+                if hasattr(gm, "model"):
+                    setattr(gm, "model", model_name)
+            except Exception:
+                pass
+    except Exception:
+        # if signature inspection fails, try common constructors defensively
+        try:
+            gm = GM(model=model_name)
+        except TypeError:
+            try:
+                gm = GM(model_name=model_name)
+            except TypeError:
+                gm = GM()
+
+    # Now try available methods
+    if hasattr(gm, "generate_content"):
+        return gm.generate_content(messages, files=files, max_output_tokens=max_output_tokens)
+    if hasattr(gm, "generate"):
+        # some versions use generate(messages,...)
+        try:
+            return gm.generate(messages, files=files, max_output_tokens=max_output_tokens)
+        except TypeError:
+            # try positional
+            return gm.generate(messages, max_output_tokens=max_output_tokens)
+    raise RuntimeError("No usable generate method on GenerativeModel instance")
+
+# Fallback HTTP call using the REST Responses endpoint if the SDK is present but broken.
+# This requires an API key and uses the public Responses API endpoint.
+def responses_http_call(api_key, model, messages, file_name=None, max_output_tokens=1024, safety_settings=None):
+    """
+    Minimal fallback: POST to the Responses API /v1/responses.
+    This constructs a small payload; note: some runtimes may block direct HTTP to Google or expect different endpoints.
+    """
+    # Basic endpoint; adjust if your environment needs a different base URL
+    url = "https://generativeai.googleapis.com/v1beta2/models/{model}:generateMessage".format(model=model)
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "messages": [{"role": m.get("role", "user"), "content": [{"type": "text", "text": m.get("content", "")}]} for m in messages],
+        "maxOutputTokens": max_output_tokens,
+    }
+    if safety_settings:
+        payload["safetySettings"] = safety_settings
+    if file_name:
+        # Attach file ref format used by some SDKs
+        payload["files"] = [{"name": file_name}]
+    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 responses fallback failed: {e}")
+
 # UI layout
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url_value"):
@@ -287,7 +363,6 @@ if st.sidebar.button("Load Video", use_container_width=True):
     try:
         vpw = st.session_state.get("video-password", "")
         url_val = st.session_state.get("url", "").strip()
-        # If URL present, try to expand and extract video from HTML first
         final_url = url_val
         html_text = None
         if url_val:
@@ -296,9 +371,7 @@ if st.sidebar.button("Load Video", use_container_width=True):
                 final_url = expanded
                 html_text = html_or_err
             else:
-                # expansion failed but html_or_err contains error message; ignore
                 html_text = None
-        # If we have HTML, try to find direct video link
         extracted = None
         if html_text:
             extracted = extract_video_from_html(html_text, base_url=final_url)
@@ -410,7 +483,7 @@ if generate_now and not st.session_state.get("busy"):
                     try:
                         if not HAS_GENAI or genai is None:
                             raise RuntimeError("Responses API not available; install google.generativeai SDK.")
-                        # ensure configured
+                        # ensure configured (best-effort)
                         try:
                             genai.configure(api_key=key_to_use)
                         except Exception:
@@ -441,16 +514,12 @@ if generate_now and not st.session_state.get("busy"):
                             diagnostics["responses.generate_error"] = str(e)
                             response = None
 
-                        # Attempt #2: GenerativeModel variants (0.8.x+)
+                        # Attempt #2: GenerativeModel variants (0.8.x+), using flexible caller
                         if response is None:
                             try:
                                 if hasattr(genai, "GenerativeModel"):
                                     diagnostics["attempts"].append("GenerativeModel")
-                                    gm = genai.GenerativeModel(model=model_used)
-                                    if hasattr(gm, "generate_content"):
-                                        response = gm.generate_content([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
-                                    elif hasattr(gm, "generate"):
-                                        response = gm.generate([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                    response = generative_model_call_flexible(model_used, [system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
                             except Exception as e:
                                 diagnostics["GenerativeModel_error"] = str(e)
                                 response = None
@@ -468,22 +537,16 @@ if generate_now and not st.session_state.get("busy"):
                                 diagnostics["top_level_error"] = str(e)
                                 response = None
 
-                        # Final defensive tries for known objects
+                        # Attempt #4: fallback HTTP Responses call
                         if response is None:
                             try:
-                                if hasattr(genai, "GenerativeModel"):
-                                    diagnostics["attempts"].append("GenerativeModel_last")
-                                    gm = genai.GenerativeModel(model=model_used)
-                                    try:
-                                        response = gm.generate_content([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
-                                    except Exception:
-                                        response = gm.generate([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                diagnostics["attempts"].append("http_fallback")
+                                response = responses_http_call(key_to_use, model_used, [system_msg, user_msg], file_name=fname, max_output_tokens=max_tokens, safety_settings=safety_settings)
                             except Exception as e:
-                                diagnostics["GenerativeModel_last_error"] = str(e)
+                                diagnostics["http_fallback_error"] = str(e)
                                 response = None
 
                         if response is None:
-                            # Instead of raising the runtime error seen previously, attach diagnostics to last_error and return gracefully
                             diag_text = f"No supported generate method found on google.generativeai in this runtime. Diagnostics: {diagnostics}"
                             st.session_state["last_error"] = diag_text
                             st.error("Responses API not supported in this runtime. See Last Error for details.")