Update app.py

app.py

@@ -78,36 +78,32 @@ google_genai_client: Optional[google_genai_sdk.Client] = None
 try:
     from langgraph.graph import StateGraph, END
     try:
-        from langgraph.prebuilt import ToolNode # Try modern ToolNode first
+        from langgraph.prebuilt import ToolNode
         LG_ToolExecutor_Class = ToolNode
         print("Using langgraph.prebuilt.ToolNode for LangGraph tool execution.")
     except ImportError:
         try:
-            from langgraph.prebuilt import ToolExecutor # Fallback to older ToolExecutor
+            from langgraph.prebuilt import 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: # Only proceed if a tool executor class was found
+    if LG_ToolExecutor_Class is not None:
         try:
             from langgraph.prebuilt import ToolInvocation as LGToolInvocationActual
         except ImportError:
             try:
-                from langgraph.tools import ToolInvocation as LGToolInvocationActual # Older path
-                print("Imported ToolInvocation from langgraph.tools (older path).")
+                from langgraph.tools import ToolInvocation as LGToolInvocationActual
+                print("Imported ToolInvocation from langgraph.tools")
             except ImportError as 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
+                print(f"WARNING: Could not import ToolInvocation from langgraph.prebuilt or langgraph.tools: {e_ti}")
+                LGToolInvocationActual = None
         
-        # 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
+        if LGToolInvocationActual is not None or type(LG_ToolExecutor_Class).__name__ == 'ToolNode':
+            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 # type: ignore
@@ -115,14 +111,14 @@ try:
         else:
             LANGGRAPH_FLAVOR_AVAILABLE = False
             LG_StateGraph, LG_END, add_messages, MemorySaver_Class = (None,) * 4 # type: ignore
-            print(f"WARNING: LangGraph ToolInvocation not found and may be required. LangGraph agent functionality might be limited or disabled.")
+            print(f"WARNING: LangGraph ToolInvocation not found and may be required by older ToolExecutor. LangGraph agent functionality might be limited or disabled.")
             
-    else: # No LG_ToolExecutor_Class found
+    else:
         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.")
 
-except ImportError as e: # Catch import error for StateGraph, END itself
+except ImportError as e:
     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 (like StateGraph, END) not found or import error: {e}. LangGraph agent will be disabled.")
@@ -259,7 +255,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(';').strip() if content_type_header else ''
+                content_type_val = content_type_header.split(';')[0].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}")
@@ -400,9 +396,9 @@ def initialize_agent_and_tools(force_reinit=False):
             model=GEMINI_MODEL_NAME,
             google_api_key=GOOGLE_API_KEY,
             temperature=0.0,
-            # safety_settings is removed to use model defaults.
+            # safety_settings is removed to use model defaults to isolate "contents not specified" error
             timeout=120,
-            convert_system_message_to_human=False # Explicitly False
+            convert_system_message_to_human=False # Explicitly set to 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:
@@ -421,61 +417,68 @@ 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, add_messages]): # LG_ToolInvocation removed from check as it's problematic
+    if LANGGRAPH_FLAVOR_AVAILABLE and all([LG_StateGraph, LG_ToolExecutor_Class, LG_END, LLM_INSTANCE, add_messages]): # LG_ToolInvocation removed from check
         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]
 
-            base_system_prompt_content = LANGGRAPH_PROMPT_TEMPLATE_STR.format(
+            base_system_prompt_content_template_lg = LANGGRAPH_PROMPT_TEMPLATE_STR.format(
                 tools="\n".join([f"- {t.name}: {t.description}" for t in TOOLS]),
-                input="{current_task_input_placeholder}" 
+                input="{current_task_input_placeholder}"
             )
 
             def agent_node(state: AgentState):
                 current_task_actual_input = state.get('input', '')
-                system_message_content = base_system_prompt_content.replace("{current_task_input_placeholder}", current_task_actual_input)
+                system_message_content = base_system_prompt_content_template_lg.replace("{current_task_input_placeholder}", current_task_actual_input)
                 
                 messages_for_llm = [SystemMessage(content=system_message_content)]
+                # If there's history, append it after the SystemMessage.
+                # The current_task_actual_input is now part of the SystemMessage.
+                # The 'messages' in state are previous AIMessages/ToolMessages.
                 messages_for_llm.extend(state.get('messages', []))
                 
                 logger.debug(f"LangGraph agent_node - messages_for_llm: {messages_for_llm}")
-                # 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.")]}
+                # Check the first message (SystemMessage)
+                if not messages_for_llm or not (isinstance(messages_for_llm[0], SystemMessage) and messages_for_llm[0].content and str(messages_for_llm[0].content).strip()):
+                    logger.error("LLM call would fail in agent_node: First message (SystemMessage) is missing, has no content, is not a string, or content is empty/whitespace.")
+                    return {"messages": [AIMessage(content="[ERROR] Agent node: Initial SystemMessage content is invalid or empty.")]}
 
-                bound_llm = LLM_INSTANCE.bind_tools(TOOLS) # type: ignore
+                bound_llm = LLM_INSTANCE.bind_tools(TOOLS)
                 response = bound_llm.invoke(messages_for_llm)
                 return {"messages": [response]}
 
-            if not LG_ToolExecutor_Class: raise ValueError("LG_ToolExecutor_Class is None for LangGraph.")
+            if not LG_ToolExecutor_Class: raise ValueError("LG_ToolExecutor_Class (ToolNode or ToolExecutor) is None for LangGraph.")
             tool_executor_instance_lg = LG_ToolExecutor_Class(tools=TOOLS)
 
-            def tool_node(state: AgentState): # This custom function invokes tools from AIMessage
+            # If LG_ToolExecutor_Class is ToolNode, it's often added directly to the graph.
+            # If we keep a custom tool_node, it needs to correctly use the tool_executor_instance_lg.
+            def tool_node(state: AgentState):
                 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": []}
                 
+                # ToolNode can often take the AIMessage directly, or a list of tool_calls
+                # The `invoke` method of ToolNode typically expects the full previous message or just tool_calls.
+                # Depending on the exact version and how ToolNode is implemented.
+                # The most straightforward is to let ToolNode handle the AIMessage's tool_calls.
+                # This implies tool_executor_instance_lg should be the node itself.
+                # However, if we must use a custom function:
                 tool_results = []
-                for tc in last_msg.tool_calls:
+                for tc in last_msg.tool_calls: # tc is a dict from AIMessage.tool_calls
                     name, args, tc_id = tc.get('name'), tc.get('args'), tc.get('id')
                     if not all([name, isinstance(args, dict), tc_id]):
                         err_msg=f"Invalid tool_call: {tc}"; logger.error(err_msg)
                         tool_results.append(ToolMessage(f"Error: {err_msg}", tool_call_id=tc_id or "error_id", name=name or "error_tool"))
                         continue
                     try:
-                        logger.info(f"LG Tool Invoking: '{name}' with {args} (ID: {tc_id})")
-                        # 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
+                        logger.info(f"LG Tool Invoking via custom tool_node: '{name}' with {args} (ID: {tc_id})")
+                        # Construct ToolInvocation if LG_ToolInvocation is available and needed by the executor_instance
+                        if LG_ToolInvocation and not isinstance(tool_executor_instance_lg, ToolNode): # ToolNode might not need this
+                             invocation = LG_ToolInvocation(tool=name, tool_input=args)
+                             output_lg = tool_executor_instance_lg.invoke(invocation) # type: ignore
+                        else: # Assume ToolNode or compatible executor can take the dict directly
+                             output_lg = tool_executor_instance_lg.invoke(tc) # Pass the tool_call dict
 
                         tool_results.append(ToolMessage(content=str(output_lg), tool_call_id=tc_id, name=name))
                     except Exception as e_tool_node_lg:
@@ -483,12 +486,15 @@ 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)
-            # 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
+            # If LG_ToolExecutor_Class is ToolNode, use the instance directly
+            if type(LG_ToolExecutor_Class).__name__ == 'ToolNode':
+                workflow_lg.add_node("tools", tool_executor_instance_lg)
+                logger.info("Added ToolNode instance directly to LangGraph.")
+            else: # Fallback to custom tool_node (might be needed for older ToolExecutor)
+                workflow_lg.add_node("tools", tool_node)
+                logger.info("Added custom tool_node function to LangGraph.")
 
             workflow_lg.set_entry_point("agent")
             def should_continue_lg(state: AgentState): return "tools" if state['messages'][-1].tool_calls else LG_END
@@ -681,7 +687,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 - Final SafetySettings and Contents Fix)...")
+    logger.info(f"Application starting up (v7.1 - Agent Node Message Structure Change)...")
     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.")