fix: enable tool calling for async agents with Gemini models

claude[bot] · MervinPraison · web-flow · commit a45618f6ee6b · 2025-07-11T10:15:56.000Z
- Created _build_system_prompt method to centralize system prompt generation
- Fixed async achat to use correct tools parameter (was always using self.tools)
- Both sync and async now use enhanced system prompt with tool information
- Added comprehensive async agent test to verify the fix

This resolves the issue where async agents would claim no internet access
even when tools were available.

Co-authored-by: Mervin Praison &lt;MervinPraison@users.noreply.github.com&gt;
diff --git a/src/praisonai-agents/praisonaiagents/agent/agent.py b/src/praisonai-agents/praisonaiagents/agent/agent.py
@@ -713,52 +713,69 @@ def _apply_guardrail_with_retry(self, response_text, prompt, temperature=0.2, to
                 )
         
         return current_response
+    
+    def _build_system_prompt(self, tools=None):
+        """Build the system prompt with tool information.
+        
+        Args:
+            tools: Optional list of tools to use (defaults to self.tools)
+            
+        Returns:
+            str: The system prompt or None if use_system_prompt is False
+        """
+        if not self.use_system_prompt:
+            return None
+            
+        system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}"""
+        
+        # Add tool usage instructions if tools are available
+        # Use provided tools or fall back to self.tools
+        tools_to_use = tools if tools is not None else self.tools
+        if tools_to_use:
+            tool_names = []
+            for tool in tools_to_use:
+                try:
+                    if callable(tool) and hasattr(tool, '__name__'):
+                        tool_names.append(tool.__name__)
+                    elif isinstance(tool, dict) and isinstance(tool.get('function'), dict) and 'name' in tool['function']:
+                        tool_names.append(tool['function']['name'])
+                    elif isinstance(tool, str):
+                        tool_names.append(tool)
+                    elif hasattr(tool, "to_openai_tool"):
+                        # Handle MCP tools
+                        openai_tools = tool.to_openai_tool()
+                        if isinstance(openai_tools, list):
+                            for t in openai_tools:
+                                if isinstance(t, dict) and 'function' in t and 'name' in t['function']:
+                                    tool_names.append(t['function']['name'])
+                        elif isinstance(openai_tools, dict) and 'function' in openai_tools:
+                            tool_names.append(openai_tools['function']['name'])
+                except (AttributeError, KeyError, TypeError) as e:
+                    logging.warning(f"Could not extract tool name from {tool}: {e}")
+                    continue
+            
+            if tool_names:
+                system_prompt += f"\n\nYou have access to the following tools: {', '.join(tool_names)}. Use these tools when appropriate to help complete your tasks. Always use tools when they can help provide accurate information or perform actions."
+        
+        return system_prompt
 
-    def _build_messages(self, prompt, temperature=0.2, output_json=None, output_pydantic=None):
+    def _build_messages(self, prompt, temperature=0.2, output_json=None, output_pydantic=None, tools=None):
         """Build messages list for chat completion.
         
         Args:
             prompt: The user prompt (str or list)
             temperature: Temperature for the chat
             output_json: Optional Pydantic model for JSON output
             output_pydantic: Optional Pydantic model for JSON output (alias)
+            tools: Optional list of tools to use (defaults to self.tools)
             
         Returns:
             tuple: (messages list, original prompt)
         """
-        # Build system prompt if enabled
-        system_prompt = None
-        if self.use_system_prompt:
-            system_prompt = f"""{self.backstory}\n
-Your Role: {self.role}\n
-Your Goal: {self.goal}"""
-            
-            # Add tool usage instructions if tools are available
-            if self.tools:
-                tool_names = []
-                for tool in self.tools:
-                    try:
-                        if callable(tool) and hasattr(tool, '__name__'):
-                            tool_names.append(tool.__name__)
-                        elif isinstance(tool, dict) and isinstance(tool.get('function'), dict) and 'name' in tool['function']:
-                            tool_names.append(tool['function']['name'])
-                        elif isinstance(tool, str):
-                            tool_names.append(tool)
-                        elif hasattr(tool, "to_openai_tool"):
-                            # Handle MCP tools
-                            openai_tools = tool.to_openai_tool()
-                            if isinstance(openai_tools, list):
-                                for t in openai_tools:
-                                    if isinstance(t, dict) and 'function' in t and 'name' in t['function']:
-                                        tool_names.append(t['function']['name'])
-                            elif isinstance(openai_tools, dict) and 'function' in openai_tools:
-                                tool_names.append(openai_tools['function']['name'])
-                    except (AttributeError, KeyError, TypeError) as e:
-                        logging.warning(f"Could not extract tool name from {tool}: {e}")
-                        continue
-                
-                if tool_names:
-                    system_prompt += f"\n\nYou have access to the following tools: {', '.join(tool_names)}. Use these tools when appropriate to help complete your tasks. Always use tools when they can help provide accurate information or perform actions."
+        # Build system prompt using the helper method
+        system_prompt = self._build_system_prompt(tools)
         
         # Use openai_client's build_messages method if available
         if self._openai_client is not None:
@@ -1202,7 +1219,7 @@ def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pyd
                     # Pass everything to LLM class
                     response_text = self.llm_instance.get_response(
                     prompt=prompt,
-                    system_prompt=f"{self.backstory}\n\nYour Role: {self.role}\n\nYour Goal: {self.goal}" if self.use_system_prompt else None,
+                    system_prompt=self._build_system_prompt(tools),
                     chat_history=self.chat_history,
                     temperature=temperature,
                     tools=tool_param,
@@ -1518,7 +1535,7 @@ async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None
                 try:
                     response_text = await self.llm_instance.get_response_async(
                         prompt=prompt,
-                        system_prompt=f"{self.backstory}\n\nYour Role: {self.role}\n\nYour Goal: {self.goal}" if self.use_system_prompt else None,
+                        system_prompt=self._build_system_prompt(tools),
                         chat_history=self.chat_history,
                         temperature=temperature,
                         tools=tools,
@@ -1532,7 +1549,7 @@ async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None
                         console=self.console,
                         agent_name=self.name,
                         agent_role=self.role,
-                        agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools],
+                        agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
                         execute_tool_fn=self.execute_tool_async,
                         reasoning_steps=reasoning_steps
                     )
diff --git a/test_async_gemini_fix.py b/test_async_gemini_fix.py
@@ -0,0 +1,163 @@
+"""
+Test to verify that async agents with Gemini models properly use tools
+after the fix for issue #818
+"""
+import asyncio
+import logging
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Enable logging to see tool calls
+logging.basicConfig(level=logging.INFO)
+
+# Mock search tool
+async def mock_search(query: str) -> dict:
+    """Mock search tool for testing"""
+    print(f"[TOOL CALLED] Searching for: {query}")
+    return {
+        "query": query,
+        "results": [
+            {
+                "title": f"Result 1 for {query}",
+                "snippet": f"This is a mock result about {query}",
+                "url": "https://example.com/1"
+            },
+            {
+                "title": f"Result 2 for {query}", 
+                "snippet": f"Another mock result about {query}",
+                "url": "https://example.com/2"
+            }
+        ],
+        "status": "success"
+    }
+
+async def test_async_gemini_tools():
+    """Test async agents with Gemini models use tools correctly"""
+    
+    # Create search agent with Gemini model
+    search_agent = Agent(
+        name="AsyncSearcher",
+        role="Research Assistant",
+        goal="Find information using the search tool",
+        backstory="You are an expert at finding information online",
+        tools=[mock_search],
+        llm={"model": "gemini/gemini-1.5-flash-latest"},
+        verbose=True
+    )
+    
+    # Create analysis agent without tools
+    analysis_agent = Agent(
+        name="Analyzer",
+        role="Data Analyst",
+        goal="Analyze search results",
+        backstory="You excel at analyzing and summarizing information",
+        llm={"model": "gemini/gemini-1.5-flash-latest"},
+        verbose=True
+    )
+    
+    # Create tasks
+    search_task = Task(
+        name="search_task",
+        description="Search for information about 'quantum computing breakthroughs 2024'",
+        expected_output="Search results with at least 2 relevant findings",
+        agent=search_agent,
+        async_execution=True
+    )
+    
+    analysis_task = Task(
+        name="analysis_task", 
+        description="Analyze the search results and provide a summary",
+        expected_output="A concise summary of the findings",
+        agent=analysis_agent,
+        context=[search_task],
+        async_execution=False
+    )
+    
+    # Create workflow
+    workflow = PraisonAIAgents(
+        agents=[search_agent, analysis_agent],
+        tasks=[search_task, analysis_task],
+        verbose=True
+    )
+    
+    # Execute async
+    print("\n🚀 Starting async agent test with Gemini models...")
+    result = await workflow.astart()
+    
+    # Check results
+    print("\n✅ Test Results:")
+    print("-" * 50)
+    
+    # Verify search agent used the tool
+    search_result = str(result)
+    if "mock result" in search_result.lower() or "tool called" in search_result.lower():
+        print("✅ SUCCESS: Search agent properly used the mock_search tool!")
+    else:
+        print("❌ FAILURE: Search agent did NOT use the tool (claimed no internet access)")
+    
+    # Show the actual output
+    print("\nFinal output:")
+    print(result)
+    
+    return result
+
+async def test_multiple_async_agents():
+    """Test multiple async agents running in parallel"""
+    
+    agents = []
+    tasks = []
+    
+    # Create 3 search agents
+    for i in range(3):
+        agent = Agent(
+            name=f"AsyncAgent{i}",
+            role="Researcher",
+            goal="Search for information",
+            backstory="Expert researcher",
+            tools=[mock_search],
+            llm={"model": "gemini/gemini-1.5-flash-latest"}
+        )
+        
+        task = Task(
+            name=f"task_{i}",
+            description=f"Search for 'AI advancement #{i+1}'",
+            expected_output="Search results",
+            agent=agent,
+            async_execution=True
+        )
+        
+        agents.append(agent)
+        tasks.append(task)
+    
+    # Execute all in parallel
+    workflow = PraisonAIAgents(agents=agents, tasks=tasks)
+    
+    print("\n🚀 Testing multiple async agents in parallel...")
+    results = await workflow.astart()
+    
+    # Verify all agents used tools
+    success_count = 0
+    for i, task in enumerate(tasks):
+        if "mock result" in str(results).lower():
+            success_count += 1
+    
+    print(f"\n✅ {success_count}/{len(tasks)} agents successfully used tools")
+    
+    return results
+
+async def main():
+    """Run all async tests"""
+    try:
+        # Test 1: Single async agent
+        await test_async_gemini_tools()
+        
+        # Test 2: Multiple async agents in parallel
+        await test_multiple_async_agents()
+        
+        print("\n🎉 All async tests completed!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during testing: {e}")
+        raise
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/test_tool_fix_documentation.md b/test_tool_fix_documentation.md
@@ -4,16 +4,27 @@
 Agents using Gemini models (`gemini/gemini-1.5-flash-8b`) were not calling provided tools, instead responding with "I do not have access to the internet" when tasked with searching.
 
 ## Root Cause
-The Gemini model through LiteLLM was not being properly instructed to use the available tools. The system prompt didn't mention the tools, and the tool_choice parameter wasn't being set.
+The Gemini model through LiteLLM was not being properly instructed to use the available tools. The system prompt didn't mention the tools, and the tool_choice parameter wasn't being set. Additionally, async agents were not passing the correct tools to the system prompt generation.
 
 ## Fix Applied (Updated)
 
 ### 1. Enhanced System Prompt (agent.py) - IMPROVED
-When tools are available, the agent's system prompt now explicitly mentions them with better error handling:
+A new `_build_system_prompt` method was created to centralize system prompt generation with tool information. This ensures both sync and async agents get the same enhanced prompt:
 
 ```python
-# In _build_messages method with enhanced error handling and MCP tool support
-if self.tools:
+# New _build_system_prompt method with enhanced error handling and MCP tool support
+def _build_system_prompt(self, tools=None):
+    """Build the system prompt with tool information."""
+    if not self.use_system_prompt:
+        return None
+        
+    system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}"""
+    
+    # Use provided tools or fall back to self.tools
+    tools_to_use = tools if tools is not None else self.tools
+    if tools_to_use:
     tool_names = []
     for tool in self.tools:
         try:
@@ -59,6 +70,20 @@ if 'tools' in params and params['tools'] and 'tool_choice' not in params:
             params['tool_choice'] = 'auto'
 ```
 
+### 3. Async Agent Fix (agent.py) - NEW
+Fixed async agents to correctly pass tools for system prompt generation:
+
+```python
+# In sync chat method:
+agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)]
+
+# Fixed in async achat method (was always using self.tools):
+agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)]
+
+# Both sync and async now use enhanced system prompt:
+system_prompt=self._build_system_prompt(tools)
+```
+
 ## Testing the Fix
 
 To test the fix, use the following code:
@@ -105,6 +130,8 @@ asyncio.run(test())
 3. **Better Model Detection**: More comprehensive Gemini model detection including variants like 'google/gemini'
 4. **Function Calling Support Check**: Uses litellm's `supports_function_calling` to verify model capabilities
 5. **Type Safety**: Added isinstance checks to prevent TypeErrors when accessing nested dictionaries
+6. **Async Agent Fix**: Fixed async agents to use the correct tools parameter instead of always using self.tools
+7. **Centralized System Prompt**: Created `_build_system_prompt` method to ensure consistency between sync and async paths
 
 ## Backward Compatibility
 - The fix only adds to existing functionality without modifying core behavior
