praisonaiagents 0.0.134__tar.gz → 0.0.136__tar.gz

{praisonaiagents-0.0.134 → praisonaiagents-0.0.136}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.134
+Version: 0.0.136
 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.134 → praisonaiagents-0.0.136}/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
@@ -16,7 +17,6 @@ from ..main import (
     ReflectionOutput,
     execute_sync_callback,
 )
-from .model_capabilities import is_gemini_internal_tool
 from rich.console import Console
 from rich.live import Live
 
@@ -380,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:
@@ -591,10 +650,14 @@ class LLM:
                 if tool_def:
                     formatted_tools.append(tool_def)
             # Handle Gemini internal tools (e.g., {"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
-            elif is_gemini_internal_tool(tool):
+            elif isinstance(tool, dict) and len(tool) == 1:
                 tool_name = next(iter(tool.keys()))
-                logging.debug(f"Using Gemini internal tool: {tool_name}")
-                formatted_tools.append(tool)
+                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)}")
                 
@@ -959,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}")
@@ -1610,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.134 → praisonaiagents-0.0.136}/praisonaiagents/llm/openai_client.py

@@ -18,7 +18,6 @@ from dataclasses import dataclass
 from rich.console import Console
 from rich.live import Live
 import inspect
-from .model_capabilities import is_gemini_internal_tool
 
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
@@ -407,10 +406,14 @@ class OpenAIClient:
                 if tool_def:
                     formatted_tools.append(tool_def)
             # Handle Gemini internal tools (e.g., {"googleSearch": {}}, {"urlContext": {}}, {"codeExecution": {}})
-            elif is_gemini_internal_tool(tool):
+            elif isinstance(tool, dict) and len(tool) == 1:
                 tool_name = next(iter(tool.keys()))
-                logging.debug(f"Using Gemini internal tool: {tool_name}")
-                formatted_tools.append(tool)
+                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.134 → praisonaiagents-0.0.136}/praisonaiagents/session.py

@@ -78,7 +78,7 @@ class Session:
         if not self.is_remote:
             default_memory_config = {
                 "provider": "rag",
-                "use_embedding": True,
+                "use_embedding": False,  # Disable embeddings to avoid OpenAI API key requirement
                 "rag_db_path": f".praison/sessions/{self.session_id}/chroma_db"
             }
             if memory_config:
@@ -96,6 +96,7 @@ class Session:
             self._memory = None
             self._knowledge = None
             self._agents_instance = None
+            self._agents = {}  # Track agents and their chat histories
         else:
             # For remote sessions, disable local memory/knowledge
             self.memory_config = {}
@@ -103,6 +104,7 @@ class Session:
             self._memory = None
             self._knowledge = None
             self._agents_instance = None
+            self._agents = {}  # Track agents and their chat histories
 
     @property
     def memory(self) -> Memory:
@@ -170,7 +172,23 @@ class Session:
             agent_kwargs["knowledge"] = knowledge
             agent_kwargs["knowledge_config"] = self.knowledge_config
 
-        return Agent(**agent_kwargs)
+        agent = Agent(**agent_kwargs)
+        
+        # Create a unique key for this agent (using name and role)
+        agent_key = f"{name}:{role}"
+        
+        # Restore chat history if it exists from previous sessions
+        if agent_key in self._agents:
+            agent.chat_history = self._agents[agent_key].get("chat_history", [])
+        else:
+            # Try to restore from memory for backward compatibility
+            restored_history = self._restore_agent_chat_history(agent_key)
+            agent.chat_history = restored_history
+        
+        # Track the agent
+        self._agents[agent_key] = {"agent": agent, "chat_history": agent.chat_history}
+        
+        return agent
 
     # Keep create_agent for backward compatibility
     def create_agent(self, *args, **kwargs) -> Agent:
@@ -189,6 +207,11 @@ class Session:
         """
         if self.is_remote:
             raise ValueError("State operations are not available for remote agent sessions")
+            
+        # Save agent chat histories first
+        self._save_agent_chat_histories()
+        
+        # Save session state
         state_text = f"Session state: {state_data}"
         self.memory.store_short_term(
             text=state_text,
@@ -212,12 +235,15 @@ class Session:
         """
         if self.is_remote:
             raise ValueError("State operations are not available for remote agent sessions")
-        # Use metadata-based search for better SQLite compatibility
+        # Use content-based search for better SQLite compatibility
         results = self.memory.search_short_term(
-            query=f"type:session_state",
+            query="Session state:",
             limit=10  # Get more results to filter by session_id
         )
 
+        # Restore agent chat histories first
+        self._restore_agent_chat_histories()
+        
         # Filter results by session_id in metadata
         for result in results:
             metadata = result.get("metadata", {})
@@ -230,6 +256,97 @@ class Session:
 
         return {}
 
+    def _restore_agent_chat_history(self, agent_key: str) -> List[Dict[str, Any]]:
+        """
+        Restore agent chat history from memory.
+        
+        Args:
+            agent_key: Unique identifier for the agent
+            
+        Returns:
+            List of chat history messages or empty list if not found
+        """
+        if self.is_remote:
+            return []
+        
+        # Search for agent chat history in memory
+        results = self.memory.search_short_term(
+            query="Agent chat history for",
+            limit=10
+        )
+        
+        # Filter results by session_id and agent_key
+        for result in results:
+            metadata = result.get("metadata", {})
+            if (metadata.get("type") == "agent_chat_history" and 
+                metadata.get("session_id") == self.session_id and
+                metadata.get("agent_key") == agent_key):
+                # Extract chat history from metadata
+                chat_history = metadata.get("chat_history", [])
+                return chat_history
+        
+        return []
+
+    def _restore_agent_chat_histories(self) -> None:
+        """
+        Restore all agent chat histories from memory.
+        """
+        if self.is_remote:
+            return
+        
+        # Search for all agent chat histories in memory
+        results = self.memory.search_short_term(
+            query="Agent chat history for",
+            limit=50  # Get many results to find all agents
+        )
+        
+        # Filter and restore chat histories for this session
+        for result in results:
+            metadata = result.get("metadata", {})
+            if (metadata.get("type") == "agent_chat_history" and 
+                metadata.get("session_id") == self.session_id):
+                agent_key = metadata.get("agent_key")
+                chat_history = metadata.get("chat_history", [])
+                
+                if agent_key and chat_history:
+                    # Store in _agents dict for later retrieval
+                    self._agents[agent_key] = {
+                        "agent": None,  # Will be populated when Agent is created
+                        "chat_history": chat_history
+                    }
+
+    def _save_agent_chat_histories(self) -> None:
+        """
+        Save all agent chat histories to memory.
+        """
+        if self.is_remote:
+            return
+        
+        for agent_key, agent_data in self._agents.items():
+            agent = agent_data.get("agent")
+            chat_history = None
+            
+            # Prioritize history from the live agent object, but fall back to restored history
+            if agent and hasattr(agent, 'chat_history'):
+                chat_history = agent.chat_history
+                agent_data["chat_history"] = chat_history  # Ensure tracked history is up-to-date
+            else:
+                chat_history = agent_data.get("chat_history")
+            
+            if chat_history is not None:
+                # Save to memory
+                history_text = f"Agent chat history for {agent_key}"
+                self.memory.store_short_term(
+                    text=history_text,
+                    metadata={
+                        "type": "agent_chat_history",
+                        "session_id": self.session_id,
+                        "user_id": self.user_id,
+                        "agent_key": agent_key,
+                        "chat_history": chat_history
+                    }
+                )
+
     def get_state(self, key: str, default: Any = None) -> Any:
         """Get a specific state value"""
         state = self.restore_state()
@@ -241,6 +358,11 @@ class Session:
         current_state[key] = value
         self.save_state(current_state)
 
+    def increment_state(self, key: str, increment: int = 1, default: int = 0) -> None:
+        """Increment a numeric state value"""
+        current_value = self.get_state(key, default)
+        self.set_state(key, current_value + increment)
+
     def add_memory(self, text: str, memory_type: str = "long", **metadata) -> None:
         """
         Add information to session memory.

{praisonaiagents-0.0.134 → praisonaiagents-0.0.136}/praisonaiagents.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.134
+Version: 0.0.136
 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.134 → praisonaiagents-0.0.136}/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.134 → praisonaiagents-0.0.136}/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.134 → praisonaiagents-0.0.136}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.134"
+version = "0.0.136"
 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.136/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()