praisonaiagents 0.0.133__tar.gz → 0.0.135__tar.gz

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.133
+Version: 0.0.135
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
 Requires-Dist: pydantic
 Requires-Dist: rich
 Requires-Dist: openai
-Requires-Dist: mcp>=1.6.0
 Requires-Dist: posthog>=3.0.0
 Requires-Dist: aiohttp>=3.8.0
 Provides-Extra: mcp

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents/llm/llm.py

@@ -2,6 +2,7 @@ import logging
 import os
 import warnings
 import re
+import inspect
 from typing import Any, Dict, List, Optional, Union, Literal, Callable
 from pydantic import BaseModel
 import time
@@ -379,6 +380,65 @@ class LLM:
             
         return function_name, arguments, tool_call_id
 
+    def _validate_and_filter_ollama_arguments(self, function_name: str, arguments: Dict[str, Any], available_tools: List) -> Dict[str, Any]:
+        """
+        Validate and filter tool call arguments for Ollama provider.
+        
+        Ollama sometimes generates tool calls with mixed parameters where arguments
+        from different functions are combined. This method validates arguments against
+        the actual function signature and removes invalid parameters.
+        
+        Args:
+            function_name: Name of the function to call
+            arguments: Arguments provided in the tool call
+            available_tools: List of available tool functions
+            
+        Returns:
+            Filtered arguments dictionary with only valid parameters
+        """
+        if not available_tools:
+            logging.debug(f"[OLLAMA_FIX] No available tools provided for validation")
+            return arguments
+            
+        # Find the target function
+        target_function = None
+        for tool in available_tools:
+            tool_name = getattr(tool, '__name__', str(tool))
+            if tool_name == function_name:
+                target_function = tool
+                break
+                
+        if not target_function:
+            logging.debug(f"[OLLAMA_FIX] Function {function_name} not found in available tools")
+            return arguments
+            
+        try:
+            # Get function signature
+            sig = inspect.signature(target_function)
+            valid_params = set(sig.parameters.keys())
+            
+            # Filter arguments to only include valid parameters
+            filtered_args = {}
+            invalid_params = []
+            
+            for param_name, param_value in arguments.items():
+                if param_name in valid_params:
+                    filtered_args[param_name] = param_value
+                else:
+                    invalid_params.append(param_name)
+                    
+            if invalid_params:
+                logging.debug(f"[OLLAMA_FIX] Function {function_name} received invalid parameters: {invalid_params}")
+                logging.debug(f"[OLLAMA_FIX] Valid parameters for {function_name}: {list(valid_params)}")
+                logging.debug(f"[OLLAMA_FIX] Original arguments: {arguments}")
+                logging.debug(f"[OLLAMA_FIX] Filtered arguments: {filtered_args}")
+                
+            return filtered_args
+            
+        except Exception as e:
+            logging.debug(f"[OLLAMA_FIX] Error validating arguments for {function_name}: {e}")
+            return arguments
+
     def _needs_system_message_skip(self) -> bool:
         """Check if this model requires skipping system messages"""
         if not self.model:
@@ -542,6 +602,7 @@ class LLM:
         - Lists of pre-formatted tools
         - Callable functions
         - String function names
+        - Gemini internal tools ({"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
         
         Args:
             tools: List of tools in various formats
@@ -588,6 +649,15 @@ class LLM:
                 tool_def = self._generate_tool_definition(tool)
                 if tool_def:
                     formatted_tools.append(tool_def)
+            # Handle Gemini internal tools (e.g., {"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
+            elif isinstance(tool, dict) and len(tool) == 1:
+                tool_name = next(iter(tool.keys()))
+                gemini_internal_tools = {'googleSearch', 'urlContext', 'codeExecution'}
+                if tool_name in gemini_internal_tools:
+                    logging.debug(f"Using Gemini internal tool: {tool_name}")
+                    formatted_tools.append(tool)
+                else:
+                    logging.debug(f"Skipping unknown tool: {tool_name}")
             else:
                 logging.debug(f"Skipping tool of unsupported type: {type(tool)}")
                 
@@ -952,6 +1022,10 @@ class LLM:
                             is_ollama = self._is_ollama_provider()
                             function_name, arguments, tool_call_id = self._extract_tool_call_info(tool_call, is_ollama)
 
+                            # Validate and filter arguments for Ollama provider
+                            if is_ollama and tools:
+                                arguments = self._validate_and_filter_ollama_arguments(function_name, arguments, tools)
+
                             logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
                             tool_result = execute_tool_fn(function_name, arguments)
                             logging.debug(f"[TOOL_EXEC_DEBUG] Tool execution result: {tool_result}")
@@ -1603,6 +1677,10 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         is_ollama = self._is_ollama_provider()
                         function_name, arguments, tool_call_id = self._extract_tool_call_info(tool_call, is_ollama)
 
+                        # Validate and filter arguments for Ollama provider
+                        if is_ollama and tools:
+                            arguments = self._validate_and_filter_ollama_arguments(function_name, arguments, tools)
+
                         tool_result = await execute_tool_fn(function_name, arguments)
                         tool_results.append(tool_result)  # Store the result
 

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents/llm/model_capabilities.py

@@ -104,4 +104,27 @@ def supports_streaming_with_tools(model_name: str) -> bool:
     """
     # For now, use the same logic as structured outputs
     # In the future, this could be a separate list if needed
-    return supports_structured_outputs(model_name)
+    return supports_structured_outputs(model_name)
+
+
+# Supported Gemini internal tools
+GEMINI_INTERNAL_TOOLS = {'googleSearch', 'urlContext', 'codeExecution'}
+
+
+def is_gemini_internal_tool(tool) -> bool:
+    """
+    Check if a tool is a Gemini internal tool and should be included in formatted tools.
+    
+    Gemini internal tools are single-key dictionaries with specific tool names.
+    Examples: {"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}}
+    
+    Args:
+        tool: The tool to check
+        
+    Returns:
+        bool: True if the tool is a recognized Gemini internal tool, False otherwise
+    """
+    if isinstance(tool, dict) and len(tool) == 1:
+        tool_name = next(iter(tool.keys()))
+        return tool_name in GEMINI_INTERNAL_TOOLS
+    return False

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents/llm/openai_client.py

@@ -360,6 +360,7 @@ class OpenAIClient:
         - Callable functions
         - String function names
         - MCP tools
+        - Gemini internal tools ({"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
         
         Args:
             tools: List of tools in various formats
@@ -404,6 +405,15 @@ class OpenAIClient:
                 tool_def = self._generate_tool_definition_from_name(tool)
                 if tool_def:
                     formatted_tools.append(tool_def)
+            # Handle Gemini internal tools (e.g., {"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
+            elif isinstance(tool, dict) and len(tool) == 1:
+                tool_name = next(iter(tool.keys()))
+                gemini_internal_tools = {'googleSearch', 'urlContext', 'codeExecution'}
+                if tool_name in gemini_internal_tools:
+                    logging.debug(f"Using Gemini internal tool: {tool_name}")
+                    formatted_tools.append(tool)
+                else:
+                    logging.debug(f"Skipping unknown tool: {tool_name}")
             else:
                 logging.debug(f"Skipping tool of unsupported type: {type(tool)}")
                 

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.133
+Version: 0.0.135
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
 Requires-Dist: pydantic
 Requires-Dist: rich
 Requires-Dist: openai
-Requires-Dist: mcp>=1.6.0
 Requires-Dist: posthog>=3.0.0
 Requires-Dist: aiohttp>=3.8.0
 Provides-Extra: mcp

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ tests/test_http_stream_basic.py
 tests/test_llm_self_reflection_direct.py
 tests/test_ollama_async_fix.py
 tests/test_ollama_fix.py
+tests/test_ollama_sequential_fix.py
 tests/test_posthog_fixed.py
 tests/test_self_reflection_comprehensive.py
 tests/test_self_reflection_fix_simple.py

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/praisonaiagents.egg-info/requires.txt

@@ -1,7 +1,6 @@
 pydantic
 rich
 openai
-mcp>=1.6.0
 posthog>=3.0.0
 aiohttp>=3.8.0
 

{praisonaiagents-0.0.133 → praisonaiagents-0.0.135}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.133"
+version = "0.0.135"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [
@@ -14,7 +14,6 @@ dependencies = [
     "pydantic",
     "rich",
     "openai",
-    "mcp>=1.6.0",
     "posthog>=3.0.0",
     "aiohttp>=3.8.0"
 ]

praisonaiagents-0.0.135/tests/test_ollama_sequential_fix.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Ollama sequential tool calling argument mixing fix.
+
+This test validates that the parameter validation and filtering fix correctly handles
+the case where Ollama generates tool calls with mixed parameters from different functions.
+"""
+
+import logging
+from praisonaiagents.llm.llm import LLM
+
+# Enable debug logging
+logging.basicConfig(level=logging.DEBUG)
+
+# Test functions matching the issue description
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    
+    Args:
+        company_name (str): The name of the company
+        
+    Returns:
+        str: The stock price of the company
+    """
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    """
+    return a * b
+
+def test_ollama_argument_validation():
+    """
+    Test the Ollama argument validation and filtering functionality.
+    """
+    print("Testing Ollama argument validation and filtering...")
+    
+    llm = LLM(model="ollama/llama3.2")
+    tools = [get_stock_price, multiply]
+    
+    # Test case 1: Valid arguments (should pass through unchanged)
+    print("\n1. Testing valid arguments:")
+    valid_args = {"a": 100, "b": 2}
+    filtered_args = llm._validate_and_filter_ollama_arguments("multiply", valid_args, tools)
+    print(f"Original: {valid_args}")
+    print(f"Filtered: {filtered_args}")
+    assert filtered_args == valid_args, "Valid arguments should pass through unchanged"
+    print("✅ Valid arguments test passed")
+    
+    # Test case 2: Mixed arguments (the actual issue from #918)
+    print("\n2. Testing mixed arguments (the main issue):")
+    mixed_args = {"a": "get_stock_price", "company_name": "Google", "b": "2"}
+    filtered_args = llm._validate_and_filter_ollama_arguments("multiply", mixed_args, tools)
+    expected_filtered = {"a": "get_stock_price", "b": "2"}  # Should remove 'company_name'
+    print(f"Original: {mixed_args}")
+    print(f"Filtered: {filtered_args}")
+    print(f"Expected: {expected_filtered}")
+    assert filtered_args == expected_filtered, f"Expected {expected_filtered}, got {filtered_args}"
+    print("✅ Mixed arguments filtering test passed")
+    
+    # Test case 3: All invalid arguments
+    print("\n3. Testing all invalid arguments:")
+    invalid_args = {"invalid_param1": "value1", "invalid_param2": "value2"}
+    filtered_args = llm._validate_and_filter_ollama_arguments("multiply", invalid_args, tools)
+    expected_empty = {}
+    print(f"Original: {invalid_args}")
+    print(f"Filtered: {filtered_args}")
+    assert filtered_args == expected_empty, "All invalid arguments should be filtered out"
+    print("✅ Invalid arguments filtering test passed")
+    
+    # Test case 4: Function not found in tools
+    print("\n4. Testing function not found:")
+    some_args = {"param": "value"}
+    filtered_args = llm._validate_and_filter_ollama_arguments("nonexistent_function", some_args, tools)
+    print(f"Original: {some_args}")
+    print(f"Filtered: {filtered_args}")
+    assert filtered_args == some_args, "Arguments should pass through if function not found"
+    print("✅ Function not found test passed")
+    
+    # Test case 5: Empty tools list
+    print("\n5. Testing empty tools list:")
+    some_args = {"param": "value"}
+    filtered_args = llm._validate_and_filter_ollama_arguments("multiply", some_args, [])
+    print(f"Original: {some_args}")
+    print(f"Filtered: {filtered_args}")
+    assert filtered_args == some_args, "Arguments should pass through if no tools provided"
+    print("✅ Empty tools test passed")
+    
+    print("\n🎉 All Ollama argument validation tests passed!")
+    return True
+
+def test_provider_detection():
+    """
+    Test the Ollama provider detection functionality.
+    """
+    print("\nTesting Ollama provider detection...")
+    
+    # Test Ollama provider detection
+    ollama_llm = LLM(model="ollama/llama3.2")
+    assert ollama_llm._is_ollama_provider(), "Should detect ollama/ prefix"
+    print("✅ Ollama prefix detection works")
+    
+    # Test non-Ollama provider
+    openai_llm = LLM(model="gpt-4o-mini")
+    assert not openai_llm._is_ollama_provider(), "Should not detect OpenAI as Ollama"
+    print("✅ Non-Ollama provider detection works")
+    
+    print("✅ Provider detection tests passed!")
+    return True
+
+if __name__ == "__main__":
+    print("Running Ollama sequential tool calling fix tests...")
+    print("=" * 60)
+    
+    # Run tests
+    try:
+        test_provider_detection()
+        test_ollama_argument_validation()
+        
+        print("\n" + "=" * 60)
+        print("🎉 ALL TESTS PASSED!")
+        print("The Ollama sequential tool calling argument mixing issue has been fixed!")
+        
+    except Exception as e:
+        print(f"\n❌ TEST FAILED: {e}")
+        import traceback
+        traceback.print_exc()