Update streamlit_app.py

streamlit_app.py

@@ -353,23 +353,105 @@ if generate_now and not st.session_state.get("busy"):
                 est_tokens = max_tokens
                 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:
-                            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)
+                # Use Responses API directly (avoid phi.Agent which can raise when candidates is empty)
+                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,
+                    )
+                
+                # Normalize response into a safe list of output items
+                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) and v:
+                                outputs = v
+                                break
                 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."}
+                    for attr in ("output", "candidates", "items", "responses"):
+                        val = getattr(response, attr, None)
+                        if isinstance(val, list) and val:
+                            outputs = val
+                            break
+                
+                # Safely extract text pieces without indexing into empty lists
+                text_pieces = []
+                for item in outputs:
+                    if item is None:
+                        continue
+                    # item may be dict or object
+                    if isinstance(item, dict):
+                        # try common fields
+                        txt = item.get("text") or item.get("output_text") or item.get("message")
+                        if isinstance(txt, str) and txt.strip():
+                            text_pieces.append(txt.strip())
+                            continue
+                        contents = item.get("content") or item.get("output")
+                    else:
+                        txt = getattr(item, "text", None) or getattr(item, "output_text", None) or getattr(item, "message", None)
+                        if isinstance(txt, str) and txt.strip():
+                            text_pieces.append(txt.strip())
+                            continue
+                        contents = getattr(item, "content", None) or getattr(item, "output", None)
+                
+                    # contents may be string or list
+                    if isinstance(contents, str) and contents.strip():
+                        text_pieces.append(contents.strip())
+                    elif isinstance(contents, (list, tuple)):
+                        for c in contents:
+                            if c is None:
+                                continue
+                            if isinstance(c, str) and 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())
+                
+                # final fallback: top-level text
+                if not text_pieces:
+                    top_text = getattr(response, "text", None) if not isinstance(response, dict) else (response.get("text") or response.get("message"))
+                    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)
 
                     try:
                         response = genai.responses.generate(