Update app.py

app.py

@@ -39,7 +39,7 @@ try: import whisper; WHISPER_AVAILABLE = True
 except ImportError: WHISPER_AVAILABLE = False; print("WARNING: OpenAI Whisper not found, Audio Transcription tool will be disabled.")
 
 # Google GenAI (Used by LangChain integration AND direct client)
-from google.genai.types import HarmCategory, HarmBlockThreshold
+from google.genai.types import HarmCategory, HarmBlockThreshold # Correct import
 from google.ai import generativelanguage as glm # For FileState enum
 
 # LangChain
@@ -62,7 +62,7 @@ LANGGRAPH_FLAVOR_AVAILABLE = False
 LG_StateGraph: Optional[Type[Any]] = None
 LG_ToolExecutor_Class: Optional[Type[Any]] = None
 LG_END: Optional[Any] = None
-LG_ToolInvocation: Optional[Type[Any]] = None
+LG_ToolInvocation: Optional[Type[Any]] = None # This import might fail based on logs
 add_messages: Optional[Any] = None
 MemorySaver_Class: Optional[Type[Any]] = None
 
@@ -83,27 +83,33 @@ try:
         print("Using langgraph.prebuilt.ToolNode for LangGraph tool execution.")
     except ImportError:
         try:
-            from langgraph.prebuilt import ToolExecutor
+            from langgraph.prebuilt import ToolExecutor # This was failing in logs
             LG_ToolExecutor_Class = ToolExecutor
             print("Using langgraph.prebuilt.ToolExecutor (fallback) for LangGraph tool execution.")
         except ImportError as e_lg_exec_inner:
              print(f"Failed to import ToolNode and ToolExecutor from langgraph.prebuilt: {e_lg_exec_inner}")
              LG_ToolExecutor_Class = None
 
-    if LG_ToolExecutor_Class is not None:
+    # This ToolInvocation import was also failing based on logs
+    try:
         from langgraph.prebuilt import ToolInvocation as LGToolInvocationActual
+    except ImportError as e_tool_inv:
+        print(f"WARNING: Failed to import ToolInvocation from langgraph.prebuilt: {e_tool_inv}")
+        LGToolInvocationActual = None # type: ignore
+
+    if LG_ToolExecutor_Class is not None and LGToolInvocationActual is not None:
         from langgraph.graph.message import add_messages as lg_add_messages
         from langgraph.checkpoint.memory import MemorySaver as LGMemorySaver
         LANGGRAPH_FLAVOR_AVAILABLE = True
         LG_StateGraph, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = \
             StateGraph, END, LGToolInvocationActual, lg_add_messages, LGMemorySaver
-        print("Successfully imported LangGraph components.")
+        print("Successfully imported essential LangGraph components.")
     else:
         LANGGRAPH_FLAVOR_AVAILABLE = False
-        LG_StateGraph, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = (None,) * 5
-        print(f"WARNING: No suitable LangGraph tool executor (ToolNode/ToolExecutor) found. LangGraph agent will be disabled.")
+        LG_StateGraph, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = (None,) * 5 # type: ignore
+        print(f"WARNING: One or more LangGraph components (ToolExecutor/Node or ToolInvocation) not found. LangGraph agent will be disabled.")
 
-except ImportError as e:
+except ImportError as e: # Catch import error for StateGraph, END itself
     LANGGRAPH_FLAVOR_AVAILABLE = False
     LG_StateGraph, LG_ToolExecutor_Class, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = (None,) * 6
     print(f"WARNING: Core LangGraph components (StateGraph, END) not found or import error: {e}. LangGraph agent will be disabled.")
@@ -142,7 +148,6 @@ else:
 
 # --- Helper Functions (Unchanged) ---
 def _strip_exact_match_answer(text: Any) -> str:
-    # ... (Your original _strip_exact_match_answer function)
     if not isinstance(text, str): text = str(text)
     text_lower_check = text.lower()
     if text_lower_check.startswith("final answer:"):
@@ -160,17 +165,14 @@ def _strip_exact_match_answer(text: Any) -> str:
     return text.strip()
 
 def _is_full_url(url_string: str) -> bool:
-    # ... (Your original _is_full_url function)
     try: result = urlparse(url_string); return all([result.scheme, result.netloc])
     except ValueError: return False
 
 def _is_youtube_url(url: str) -> bool:
-    # ... (Your original _is_youtube_url function)
     parsed_url = urlparse(url)
     return parsed_url.netloc.lower().endswith(("youtube.com", "youtu.be"))
 
 def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None) -> str:
-    # ... (Your original _download_file function - unchanged) ...
     os.makedirs(LOCAL_FILE_STORE_PATH, exist_ok=True)
     logger.debug(f"Download request: '{file_identifier}', task_id: {task_id_for_file}")
     original_filename = os.path.basename(urlparse(file_identifier).path) if _is_full_url(file_identifier) else os.path.basename(file_identifier)
@@ -244,7 +246,7 @@ def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None)
             name_without_ext, current_ext = os.path.splitext(effective_save_path)
             if not current_ext:
                 content_type_header = r.headers.get('content-type', '')
-                content_type_val = content_type_header.split(';')[0].strip() if content_type_header else ''
+                content_type_val = content_type_header.split(';').strip() if content_type_header else ''
                 if content_type_val:
                     guessed_ext = mimetypes.guess_extension(content_type_val)
                     if guessed_ext: effective_save_path += guessed_ext; logger.info(f"Added guessed ext: {guessed_ext}")
@@ -380,27 +382,18 @@ def initialize_agent_and_tools(force_reinit=False):
     logger.info("Initializing agent and tools...")
     if not GOOGLE_API_KEY: raise ValueError("GOOGLE_API_KEY not set for LangChain LLM.")
     
-    # Using INTEGER VALUES for HarmCategory keys and HarmBlockThreshold enum .value for values.
-    llm_safety_settings_corrected_final = {
-        HarmCategory.HARM_CATEGORY_HARASSMENT.value: HarmBlockThreshold.BLOCK_NONE.value,
-        HarmCategory.HARM_CATEGORY_HATE_SPEECH.value: HarmBlockThreshold.BLOCK_NONE.value,
-        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT.value: HarmBlockThreshold.BLOCK_NONE.value,
-        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT.value: HarmBlockThreshold.BLOCK_NONE.value,
-    }
-    
     try:
         LLM_INSTANCE = ChatGoogleGenerativeAI(
             model=GEMINI_MODEL_NAME,
             google_api_key=GOOGLE_API_KEY,
             temperature=0.0,
-            #safety_settings=llm_safety_settings_corrected_final,
+            # safety_settings=... # Temporarily removed to isolate 'contents' error
             timeout=120,
-            convert_system_message_to_human=True # This flag might be interacting with how system prompts are handled
+            convert_system_message_to_human=False # Set to False as it's deprecated and might cause issues
         )
-        logger.info(f"LangChain LLM (Planner) initialized: {GEMINI_MODEL_NAME}")
+        logger.info(f"LangChain LLM (Planner) initialized: {GEMINI_MODEL_NAME} (Using default safety settings, convert_system_message_to_human=False)")
     except Exception as e:
-        logger.error(f"LangChain LLM init failed: {e}", exc_info=True)
-        logger.error(f"Type of safety_settings attempted: {type(llm_safety_settings_corrected_final)}, content: {llm_safety_settings_corrected_final}")
+        logger.error(f"LangChain LLM init FAILED: {e}", exc_info=True)
         raise
 
     TOOLS = []
@@ -426,27 +419,28 @@ def initialize_agent_and_tools(force_reinit=False):
                 tools="\n".join([f"- {t.name}: {t.description}" for t in TOOLS]), input="{input}"
             )
             def agent_node(state: AgentState):
-                current_input = state.get('input', '')
-                # The LANGGRAPH_PROMPT_TEMPLATE_STR serves as the system message, with the current task input.
-                system_message_content = prompt_content_lg_init.replace("{input}", current_input)
+                current_task_input_lg = state.get('input', '')
+                system_message_content_lg = prompt_content_lg_init.replace("{input}", current_task_input_lg)
                 
-                # Messages for LLM: System prompt followed by history
-                messages_for_llm = [SystemMessage(content=system_message_content)] + state.get('messages', [])
+                # Ensure the first message passed to LLM is appropriate
+                # If convert_system_message_to_human is False, Gemini can often take a SystemMessage first.
+                messages_for_llm_lg = [SystemMessage(content=system_message_content_lg)] + state.get('messages', [])
                 
-                logger.debug(f"LangGraph agent_node - messages_for_llm: {messages_for_llm}")
-                if not messages_for_llm or (isinstance(messages_for_llm[0], SystemMessage) and not messages_for_llm[0].content.strip()):
-                    logger.error("LLM call would fail: first message is SystemMessage with no/empty content or messages_for_llm is empty.")
-                    return {"messages": [AIMessage(content="[ERROR] Agent node: System message content is empty.")]}
+                logger.debug(f"LangGraph agent_node - messages_for_llm: {messages_for_llm_lg}")
+                if not messages_for_llm_lg or not messages_for_llm_lg.content.strip():
+                    logger.error("LLM call would fail in agent_node: first message is empty or no messages.")
+                    return {"messages": [AIMessage(content="[ERROR] Agent node received no content to process.")]}
 
-                bound_llm = LLM_INSTANCE.bind_tools(TOOLS) # type: ignore
-                response = bound_llm.invoke(messages_for_llm)
-                return {"messages": [response]}
+                bound_llm_lg = LLM_INSTANCE.bind_tools(TOOLS) # type: ignore
+                response_lg = bound_llm_lg.invoke(messages_for_llm_lg)
+                return {"messages": [response_lg]}
 
             if not LG_ToolExecutor_Class: raise ValueError("LG_ToolExecutor_Class is None for LangGraph.")
             tool_executor_instance_lg = LG_ToolExecutor_Class(tools=TOOLS)
 
 
             def tool_node(state: AgentState):
+                # ... (tool_node logic from previous version - should be okay if ToolNode/ToolExecutor is correctly instantiated)
                 last_msg = state['messages'][-1] if state.get('messages') and isinstance(state['messages'][-1], AIMessage) else None
                 if not last_msg or not last_msg.tool_calls: return {"messages": []}
                 tool_results = []
@@ -466,9 +460,10 @@ def initialize_agent_and_tools(force_reinit=False):
                         tool_results.append(ToolMessage(content=f"Error for tool {name}: {str(e_tool_node_lg)}", tool_call_id=tc_id, name=name))
                 return {"messages": tool_results}
 
+
             workflow_lg = LG_StateGraph(AgentState) # type: ignore
             workflow_lg.add_node("agent", agent_node)
-            workflow_lg.add_node("tools", tool_node)
+            workflow_lg.add_node("tools", tool_node) 
             workflow_lg.set_entry_point("agent")
             def should_continue_lg(state: AgentState): return "tools" if state['messages'][-1].tool_calls else LG_END
             workflow_lg.add_conditional_edges("agent", should_continue_lg, {"tools": "tools", LG_END: LG_END}) # type: ignore
@@ -513,7 +508,6 @@ def get_agent_response(prompt: str, task_id: Optional[str]=None, thread_id: Opti
     try:
         if is_langgraph_agent_get:
             logger.debug(f"Using LangGraph agent (Memory: {LANGGRAPH_MEMORY_SAVER is not None}) for thread: {thread_id_to_use}")
-            # The 'input' for LangGraph state is the fully constructed prompt for the task
             input_for_lg_get = {"input": prompt, "messages": []}
             final_state_lg_get = AGENT_INSTANCE.invoke(input_for_lg_get, {"configurable": {"thread_id": thread_id_to_use}}) # type: ignore
             if not final_state_lg_get or 'messages' not in final_state_lg_get or not final_state_lg_get['messages']:
@@ -523,10 +517,13 @@ def get_agent_response(prompt: str, task_id: Optional[str]=None, thread_id: Opti
                     return str(message_item_lg_get.content)
             logger.warning("LangGraph: No suitable final AIMessage without tool_calls.")
             return str(final_state_lg_get['messages'][-1].content) if final_state_lg_get['messages'] else "[ERROR] LangGraph: Empty messages."
-        elif isinstance(AGENT_INSTANCE, AgentExecutor):
-            logger.debug("Using ReAct agent.")
-            response_react_get = AGENT_INSTANCE.invoke({"input": prompt})
-            return str(response_react_get.get("output", "[ERROR] ReAct: No 'output' key."))
+        elif isinstance(AGENT_INSTANCE, AgentExecutor): # ReAct agent
+            logger.debug("Using ReAct agent for get_agent_response.")
+            react_input = {"input": prompt}
+            logger.debug(f"ReAct input: {react_input}")
+            response_react_get = AGENT_INSTANCE.invoke(react_input)
+            logger.debug(f"ReAct response: {response_react_get}")
+            return str(response_react_get.get("output", "[ERROR] ReAct: No 'output' key in response."))
         else:
             logger.error(f"Unknown agent type: {agent_name_get}"); return f"[ERROR] Unknown agent type: {agent_name_get}"
     except Exception as e_agent_run_get:
@@ -633,7 +630,7 @@ with gr.Blocks(css=".gradio-container {max-width:1280px !important;margin:auto !
     demo.load(update_ui_on_load_fn_within_context, [], [agent_status_display, missing_secrets_display])
 
 if __name__ == "__main__":
-    logger.info(f"Application starting up (v7 - Corrected HarmCategory/BlockThreshold Import & SafetySettings format)...")
+    logger.info(f"Application starting up (v7 - Corrected GenAI Types Import & Removed Safety Settings from LLM)...")
     if not PYPDF2_AVAILABLE: logger.warning("PyPDF2 (PDF tool) NOT AVAILABLE.")
     if not PIL_TESSERACT_AVAILABLE: logger.warning("Pillow/Pytesseract (OCR tool) NOT AVAILABLE.")
     if not WHISPER_AVAILABLE: logger.warning("Whisper (Audio tool) NOT AVAILABLE.")