Update app.py

app.py

@@ -38,9 +38,9 @@ except ImportError: PIL_TESSERACT_AVAILABLE = False; print("WARNING: Pillow or P
 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 # Correct import
-from google.ai import generativelanguage as glm # For FileState enum
+# Google GenAI SDK types
+from google.genai.types import HarmCategory, HarmBlockThreshold
+from google.ai import generativelanguage as glm
 
 # LangChain
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage
@@ -78,42 +78,46 @@ google_genai_client: Optional[google_genai_sdk.Client] = None
 try:
     from langgraph.graph import StateGraph, END
     try:
-        langgraph.prebuilt.tool_node.ToolNode
+        from langgraph.prebuilt import ToolNode # Try modern ToolNode first
         LG_ToolExecutor_Class = ToolNode
         print("Using langgraph.prebuilt.ToolNode for LangGraph tool execution.")
     except ImportError:
         try:
-            from langgraph.prebuilt import ToolExecutor
+            from langgraph.prebuilt import ToolExecutor # Fallback to older ToolExecutor
             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:
-        # ToolInvocation might still be an issue depending on langgraph version
+    if LG_ToolExecutor_Class is not None: # Only proceed if a tool executor class was found
         try:
             from langgraph.prebuilt import ToolInvocation as LGToolInvocationActual
         except ImportError:
-            try: # Older path for ToolInvocation
-                from langgraph.tools import ToolInvocation as LGToolInvocationActual
-                print("Imported ToolInvocation from langgraph.tools")
+            try:
+                from langgraph.tools import ToolInvocation as LGToolInvocationActual # Older path
+                print("Imported ToolInvocation from langgraph.tools (older path).")
             except ImportError as e_ti:
-                print(f"WARNING: Could not import ToolInvocation from langgraph.prebuilt or langgraph.tools: {e_ti}")
+                print(f"WARNING: Could not import ToolInvocation from langgraph.prebuilt or langgraph.tools: {e_ti}. LangGraph may not function fully if ToolExecutor_Class requires it.")
                 LGToolInvocationActual = None # type: ignore
-
-        if LGToolInvocationActual is not None:
-            from langgraph.graph.message import add_messages as lg_add_messages
-            from langgraph.checkpoint.memory import MemorySaver as LGMemorySaver
+        
+        # Other essential LangGraph imports
+        from langgraph.graph.message import add_messages as lg_add_messages
+        from langgraph.checkpoint.memory import MemorySaver as LGMemorySaver
+        
+        # Set LANGGRAPH_FLAVOR_AVAILABLE only if all critical components for your setup are loaded.
+        # If LGToolInvocationActual is critical for your chosen LG_ToolExecutor_Class, check it here.
+        if LGToolInvocationActual is not None or type(LG_ToolExecutor_Class).__name__ == 'ToolNode': # ToolNode might not need separate ToolInvocation
             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.")
+                StateGraph, END, LGToolInvocationActual, lg_add_messages, LGMemorySaver # type: ignore
+            print("Successfully imported essential LangGraph components.")
         else:
-            LANGGRAPH_FLAVOR_AVAILABLE = False # Set to False if ToolInvocation is missing
+            LANGGRAPH_FLAVOR_AVAILABLE = False
             LG_StateGraph, LG_END, add_messages, MemorySaver_Class = (None,) * 4 # type: ignore
-            print(f"WARNING: LangGraph ToolInvocation not found. LangGraph agent will be disabled.")
-    else:
+            print(f"WARNING: LangGraph ToolInvocation not found and may be required. LangGraph agent functionality might be limited or disabled.")
+            
+    else: # No LG_ToolExecutor_Class found
         LANGGRAPH_FLAVOR_AVAILABLE = False
         LG_StateGraph, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = (None,) * 5 # type: ignore
         print(f"WARNING: No suitable LangGraph tool executor (ToolNode/ToolExecutor) found. LangGraph agent will be disabled.")
@@ -121,7 +125,7 @@ try:
 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.")
+    print(f"WARNING: Core LangGraph components (like StateGraph, END) not found or import error: {e}. LangGraph agent will be disabled.")
 
 
 # --- Constants ---
@@ -396,9 +400,9 @@ def initialize_agent_and_tools(force_reinit=False):
             model=GEMINI_MODEL_NAME,
             google_api_key=GOOGLE_API_KEY,
             temperature=0.0,
-            # safety_settings are removed to use model defaults, to isolate "contents not specified" error
+            # safety_settings is removed to use model defaults.
             timeout=120,
-            convert_system_message_to_human=False # Explicitly set to False
+            convert_system_message_to_human=False # Explicitly False
         )
         logger.info(f"LangChain LLM (Planner) initialized: {GEMINI_MODEL_NAME} (Using default safety settings, convert_system_message_to_human=False)")
     except Exception as e:
@@ -417,27 +421,30 @@ def initialize_agent_and_tools(force_reinit=False):
     except Exception as e: logger.warning(f"PythonREPLTool init failed: {e}")
     logger.info(f"Final tools list for agent: {[t.name for t in TOOLS]}")
 
-    if LANGGRAPH_FLAVOR_AVAILABLE and all([LG_StateGraph, LG_ToolExecutor_Class, LG_END, LLM_INSTANCE, LG_ToolInvocation, add_messages]):
+    if LANGGRAPH_FLAVOR_AVAILABLE and all([LG_StateGraph, LG_ToolExecutor_Class, LG_END, LLM_INSTANCE, add_messages]): # LG_ToolInvocation removed from check as it's problematic
         if not LANGGRAPH_MEMORY_SAVER and MemorySaver_Class: LANGGRAPH_MEMORY_SAVER = MemorySaver_Class(); logger.info("LangGraph MemorySaver initialized.")
         try:
             logger.info(f"Attempting LangGraph init (Tool Executor type: {LG_ToolExecutor_Class.__name__ if LG_ToolExecutor_Class else 'None'})")
             _TypedDict = getattr(__import__('typing_extensions'), 'TypedDict', dict)
             class AgentState(_TypedDict): input: str; messages: Annotated[List[Any], add_messages]
 
-            prompt_content_lg_init = LANGGRAPH_PROMPT_TEMPLATE_STR.format(
-                tools="\n".join([f"- {t.name}: {t.description}" for t in TOOLS]), input="{input}"
+            base_system_prompt_content = LANGGRAPH_PROMPT_TEMPLATE_STR.format(
+                tools="\n".join([f"- {t.name}: {t.description}" for t in TOOLS]),
+                input="{current_task_input_placeholder}" 
             )
+
             def agent_node(state: AgentState):
-                current_task_input_for_system_prompt = state.get('input', '')
-                system_message_content = prompt_content_lg_init.replace("{input}", current_task_input_for_system_prompt)
+                current_task_actual_input = state.get('input', '')
+                system_message_content = base_system_prompt_content.replace("{current_task_input_placeholder}", current_task_actual_input)
                 
                 messages_for_llm = [SystemMessage(content=system_message_content)]
                 messages_for_llm.extend(state.get('messages', []))
                 
                 logger.debug(f"LangGraph agent_node - messages_for_llm: {messages_for_llm}")
-                if not messages_for_llm.content.strip(): # Check specifically if the system message content is empty
-                    logger.error("LLM call would fail in agent_node: SystemMessage content is empty.")
-                    return {"messages": [AIMessage(content="[ERROR] Agent node: System message content is empty.")]}
+                # Check the content of the first message (SystemMessage)
+                if not messages_for_llm or not (isinstance(messages_for_llm, SystemMessage) and messages_for_llm.content and messages_for_llm.content.strip()):
+                    logger.error("LLM call would fail in agent_node: First message (SystemMessage) is empty or not valid.")
+                    return {"messages": [AIMessage(content="[ERROR] Agent node: Initial SystemMessage content is empty or invalid.")]}
 
                 bound_llm = LLM_INSTANCE.bind_tools(TOOLS) # type: ignore
                 response = bound_llm.invoke(messages_for_llm)
@@ -446,10 +453,10 @@ def initialize_agent_and_tools(force_reinit=False):
             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):
+            def tool_node(state: AgentState): # This custom function invokes tools from AIMessage
                 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 = []
                 for tc in last_msg.tool_calls:
                     name, args, tc_id = tc.get('name'), tc.get('args'), tc.get('id')
@@ -459,18 +466,30 @@ def initialize_agent_and_tools(force_reinit=False):
                         continue
                     try:
                         logger.info(f"LG Tool Invoking: '{name}' with {args} (ID: {tc_id})")
-                        if not LG_ToolInvocation: raise ValueError("LG_ToolInvocation is None, cannot proceed with LangGraph tool node.")
-                        tool_invocation_obj_lg = LG_ToolInvocation(tool=name, tool_input=args) # type: ignore
-                        output_lg = tool_executor_instance_lg.invoke(tool_invocation_obj_lg) # type: ignore
+                        # ToolNode expects a ToolInvocation if it's not being used as a direct runnable node for the whole tool step
+                        # However, if LG_ToolExecutor_Class is ToolNode, it's designed to take the list of tool_calls directly.
+                        # The issue was that LG_ToolInvocation itself might not be importable.
+                        # If LG_ToolExecutor_Class is ToolNode, it should handle the invocation from tool_calls.
+                        # Let's simplify and pass the tool_call directly if it's ToolNode
+                        if LG_ToolInvocation and type(LG_ToolExecutor_Class).__name__ != 'ToolNode':
+                            tool_invocation_obj_lg = LG_ToolInvocation(tool=name, tool_input=args)
+                            output_lg = tool_executor_instance_lg.invoke(tool_invocation_obj_lg) # type: ignore
+                        else: # Assume tool_executor_instance_lg (e.g. ToolNode) can handle the raw tool_call dict
+                            output_lg = tool_executor_instance_lg.invoke(tc) # type: ignore
+
                         tool_results.append(ToolMessage(content=str(output_lg), tool_call_id=tc_id, name=name))
                     except Exception as e_tool_node_lg:
                         logger.error(f"LG Tool Error ('{name}'): {e_tool_node_lg}", exc_info=True)
                         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)
+            # If LG_ToolExecutor_Class is ToolNode, tool_executor_instance_lg is a runnable node.
+            # workflow_lg.add_node("tools", tool_executor_instance_lg) # This is the more standard LangGraph way for ToolNode
+            workflow_lg.add_node("tools", tool_node) # Keeping custom for now due to ToolInvocation import issues
+
             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
@@ -541,6 +560,10 @@ def get_agent_response(prompt: str, task_id: Optional[str]=None, thread_id: Opti
             last_message_in_history = final_state_lg_get['messages'][-1]
             if hasattr(last_message_in_history, 'content') and isinstance(last_message_in_history.content, str):
                 return f"[INFO] Fallback to last message content: {str(last_message_in_history.content)}"
+            elif hasattr(last_message_in_history, 'content') and isinstance(last_message_in_history.content, list):
+                 return f"[INFO] Fallback to last message (list content): {str(last_message_in_history.content)[:150]}"
+            elif isinstance(last_message_in_history, ToolMessage):
+                 return f"[INFO] Fallback to ToolMessage content: {str(last_message_in_history.content)[:150]}"
             else:
                 logger.error(f"LangGraph: Could not extract string content from the very last message: {last_message_in_history}")
                 return "[ERROR] LangGraph: Could not extract final answer from messages."
@@ -658,12 +681,12 @@ 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 - Removed safety_settings from LLM, convert_system_message_to_human=False)...")
+    logger.info(f"Application starting up (v7 - Final SafetySettings and Contents Fix)...")
     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.")
     if LANGGRAPH_FLAVOR_AVAILABLE: logger.info(f"Core LangGraph components (StateGraph, END, {type(LG_ToolExecutor_Class).__name__ if LG_ToolExecutor_Class else 'FailedExecutor'}) loaded.")
-    else: logger.warning("Core LangGraph FAILED import or essential component (ToolExecutor/Node) missing. ReAct fallback. Check requirements & Space build logs.")
+    else: logger.warning("Core LangGraph FAILED import or essential component (ToolExecutor/Node/Invocation) missing. ReAct fallback. Check requirements & Space build logs.")
 
     missing_vars_startup_list_global.clear()
     if not GOOGLE_API_KEY: missing_vars_startup_list_global.append("GOOGLE_API_KEY")
@@ -686,4 +709,4 @@ if __name__ == "__main__":
 
     logger.info(f"Space ID: {os.getenv('SPACE_ID', 'Not Set')}")
     logger.info("Gradio Interface launching...")
-    demo.queue().launch(debug=os.getenv("GRADIO_DEBUG","false").lower()=="true", share=False, max_threads=20)
+    demo.queue().launch(debug=os.getenv("GRADIO_DEBUG","false").lower()=="true", share=False, max_threads=20)```