Release v4.5.12

Author: MervinPraison

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.11" \
+    "praisonai>=4.5.12" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.11" \
+    "praisonai>=4.5.12" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.11" \
+    "praisonai>=4.5.12" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -5285,6 +5285,54 @@ def session_id(self) -> Optional[str]:
         """Get the current session ID."""
         return self._session_id
 
+    def as_tool(
+        self,
+        description: Optional[str] = None,
+        tool_name: Optional[str] = None,
+    ) -> 'Handoff':
+        """Convert this agent to a callable tool for use by other agents.
+        
+        Unlike handoffs which pass conversation context, as_tool() creates a tool
+        where the child agent receives only the generated input (no history).
+        The parent agent retains control and receives the result.
+        
+        This is useful for hierarchical agent composition where you want to
+        invoke a specialist agent as a subordinate tool.
+        
+        Args:
+            description: Tool description for the LLM (what this agent does)
+            tool_name: Custom tool name (default: invoke_<agent_name>)
+        
+        Returns:
+            Handoff configured as a tool with no context passed
+        
+        Example:
+            researcher = Agent(name="Researcher", instructions="Research topics")
+            coder = Agent(name="Coder", instructions="Write Python code")
+            
+            writer = Agent(
+                name="Writer",
+                tools=[
+                    researcher.as_tool("Research a topic and return findings"),
+                    coder.as_tool("Write Python code for a given task"),
+                ]
+            )
+            
+            result = writer.chat("Write an article about async Python")
+        """
+        from .handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        # Generate default tool name
+        agent_name_snake = self.name.lower().replace(' ', '_').replace('-', '_')
+        default_tool_name = f"invoke_{agent_name_snake}"
+        
+        return Handoff(
+            agent=self,
+            tool_name_override=tool_name or default_tool_name,
+            tool_description_override=description or f"Invoke {self.name} to complete a subtask and return the result",
+            config=HandoffConfig(context_policy=ContextPolicy.NONE),
+        )
+
     def chat(self, prompt, temperature=1.0, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, stream=None, task_name=None, task_description=None, task_id=None, config=None, force_retrieval=False, skip_retrieval=False, attachments=None, tool_choice=None):
         """
         Chat with the agent.

src/praisonai-agents/praisonaiagents/agent/handoff.py

@@ -10,7 +10,7 @@
 - Replaces/absorbs Agent.delegate() and SubagentDelegator functionality
 """
 
-from typing import Optional, Any, Callable, Dict, List, TYPE_CHECKING
+from typing import Optional, Any, Callable, Dict, List, Union, TYPE_CHECKING
 from dataclasses import dataclass, field
 from enum import Enum
 import inspect
@@ -209,7 +209,7 @@ def __init__(
         tool_description_override: Optional[str] = None,
         on_handoff: Optional[Callable] = None,
         input_type: Optional[type] = None,
-        input_filter: Optional[Callable[[HandoffInputData], HandoffInputData]] = None,
+        input_filter: Optional[Union[Callable[[HandoffInputData], HandoffInputData], List[Callable[[HandoffInputData], HandoffInputData]]]] = None,
         config: Optional[HandoffConfig] = None,
     ):
         """
@@ -221,7 +221,8 @@ def __init__(
             tool_description_override: Custom tool description
             on_handoff: Callback function executed when handoff is invoked
             input_type: Type of input expected by the handoff (for structured data)
-            input_filter: Function to filter/transform input before passing to target agent
+            input_filter: Function or list of functions to filter/transform input.
+                When a list is provided, filters are applied in order (chaining).
             config: HandoffConfig for advanced settings (context policy, timeouts, etc.)
         """
         self.agent = agent
@@ -329,9 +330,14 @@ def _prepare_context(self, source_agent: 'Agent', kwargs: Dict[str, Any]) -> Han
             handoff_chain=_get_handoff_chain()[:],
         )
 
-        # Apply custom input filter if provided
+        # Apply custom input filter(s) if provided
+        # Supports both single filter and list of filters for chaining
         if self.input_filter:
-            handoff_data = self.input_filter(handoff_data)
+            if isinstance(self.input_filter, list):
+                for filter_fn in self.input_filter:
+                    handoff_data = filter_fn(handoff_data)
+            else:
+                handoff_data = self.input_filter(handoff_data)
 
         return handoff_data
 
@@ -790,6 +796,36 @@ def remove_system_messages(data: HandoffInputData) -> HandoffInputData:
 
         data.messages = filtered_messages
         return data
+    
+    @staticmethod
+    def compress_history(data: HandoffInputData) -> HandoffInputData:
+        """Compress all messages into a single summary message.
+        
+        This filter concatenates all message contents into one user message,
+        reducing token usage while preserving context. Useful for handoffs
+        where the target agent needs context but not full conversation history.
+        
+        Example:
+            Handoff(agent=target, input_filter=handoff_filters.compress_history)
+        """
+        if not data.messages:
+            return data
+        
+        summary_parts = []
+        for msg in data.messages:
+            if isinstance(msg, dict):
+                role = msg.get('role', 'unknown')
+                content = msg.get('content', '')
+                if content:
+                    summary_parts.append(f"[{role}]: {content}")
+        
+        if summary_parts:
+            summary = "\n".join(summary_parts)
+            data.messages = [{"role": "user", "content": f"Previous conversation summary:\n{summary}"}]
+        else:
+            data.messages = []
+        
+        return data
 
 
 # Recommended prompt prefix for agents that use handoffs

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "1.5.11"
+version = "1.5.12"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"

src/praisonai-agents/tests/unit/test_agent_as_tool.py

@@ -0,0 +1,187 @@
+"""
+Unit tests for Agent.as_tool() method.
+
+Tests:
+1. as_tool() returns a Handoff with ContextPolicy.NONE
+2. as_tool() generates correct default tool name
+3. as_tool() uses custom description and name when provided
+4. as_tool() can be used in tools list
+"""
+
+from unittest.mock import MagicMock
+
+
+class TestAgentAsTool:
+    """Tests for Agent.as_tool() method."""
+    
+    def test_as_tool_returns_handoff(self):
+        """Test that as_tool() returns a Handoff instance."""
+        from praisonaiagents.agent.handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        # Create a mock agent
+        mock_agent = MagicMock()
+        mock_agent.name = "TestAgent"
+        mock_agent.role = "Test Role"
+        mock_agent.goal = "Test Goal"
+        
+        # Simulate as_tool behavior
+        agent_name_snake = mock_agent.name.lower().replace(' ', '_').replace('-', '_')
+        default_tool_name = f"invoke_{agent_name_snake}"
+        
+        result = Handoff(
+            agent=mock_agent,
+            tool_name_override=default_tool_name,
+            tool_description_override=f"Invoke {mock_agent.name} to complete a subtask and return the result",
+            config=HandoffConfig(context_policy=ContextPolicy.NONE),
+        )
+        
+        assert isinstance(result, Handoff)
+        assert result.config.context_policy == ContextPolicy.NONE
+        assert result.tool_name == "invoke_testagent"
+    
+    def test_as_tool_context_policy_none(self):
+        """Test that as_tool() uses ContextPolicy.NONE (no history passed)."""
+        from praisonaiagents.agent.handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        mock_agent = MagicMock()
+        mock_agent.name = "Researcher"
+        
+        result = Handoff(
+            agent=mock_agent,
+            tool_name_override="invoke_researcher",
+            tool_description_override="Research topics",
+            config=HandoffConfig(context_policy=ContextPolicy.NONE),
+        )
+        
+        assert result.config.context_policy == ContextPolicy.NONE
+    
+    def test_as_tool_default_tool_name(self):
+        """Test that as_tool() generates correct default tool name."""
+        from praisonaiagents.agent.handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        # Test various agent names
+        test_cases = [
+            ("Researcher", "invoke_researcher"),
+            ("Code Writer", "invoke_code_writer"),
+            ("data-analyst", "invoke_data_analyst"),
+            ("MyAgent123", "invoke_myagent123"),
+        ]
+        
+        for agent_name, expected_tool_name in test_cases:
+            mock_agent = MagicMock()
+            mock_agent.name = agent_name
+            
+            agent_name_snake = agent_name.lower().replace(' ', '_').replace('-', '_')
+            tool_name = f"invoke_{agent_name_snake}"
+            
+            result = Handoff(
+                agent=mock_agent,
+                tool_name_override=tool_name,
+                tool_description_override="Test",
+                config=HandoffConfig(context_policy=ContextPolicy.NONE),
+            )
+            
+            assert result.tool_name == expected_tool_name, f"Failed for {agent_name}"
+    
+    def test_as_tool_custom_description(self):
+        """Test that as_tool() uses custom description when provided."""
+        from praisonaiagents.agent.handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        mock_agent = MagicMock()
+        mock_agent.name = "Coder"
+        
+        custom_description = "Write Python code for any task"
+        
+        result = Handoff(
+            agent=mock_agent,
+            tool_name_override="invoke_coder",
+            tool_description_override=custom_description,
+            config=HandoffConfig(context_policy=ContextPolicy.NONE),
+        )
+        
+        assert result.tool_description == custom_description
+    
+    def test_as_tool_custom_name(self):
+        """Test that as_tool() uses custom tool name when provided."""
+        from praisonaiagents.agent.handoff import Handoff, HandoffConfig, ContextPolicy
+        
+        mock_agent = MagicMock()
+        mock_agent.name = "Researcher"
+        
+        custom_name = "research_topic"
+        
+        result = Handoff(
+            agent=mock_agent,
+            tool_name_override=custom_name,
+            tool_description_override="Research topics",
+            config=HandoffConfig(context_policy=ContextPolicy.NONE),
+        )
+        
+        assert result.tool_name == custom_name
+
+
+class TestAgentAsToolIntegration:
+    """Integration tests for Agent.as_tool() with real Agent instances."""
+    
+    def test_as_tool_on_real_agent(self):
+        """Test as_tool() on a real Agent instance (no LLM calls)."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.handoff import Handoff, ContextPolicy
+        
+        # Create a real agent (no LLM calls needed for this test)
+        agent = Agent(
+            name="TestResearcher",
+            instructions="Research topics thoroughly",
+        )
+        
+        # Call as_tool()
+        result = agent.as_tool("Research a topic and return findings")
+        
+        # Verify result
+        assert isinstance(result, Handoff)
+        assert result.config.context_policy == ContextPolicy.NONE
+        assert result.tool_name == "invoke_testresearcher"
+        assert "Research a topic" in result.tool_description
+    
+    def test_as_tool_with_custom_params(self):
+        """Test as_tool() with custom tool name and description."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.handoff import Handoff, ContextPolicy
+        
+        agent = Agent(
+            name="Coder",
+            instructions="Write clean Python code",
+        )
+        
+        result = agent.as_tool(
+            description="Generate Python code for any programming task",
+            tool_name="generate_code",
+        )
+        
+        assert isinstance(result, Handoff)
+        assert result.tool_name == "generate_code"
+        assert "Generate Python code" in result.tool_description
+    
+    def test_as_tool_in_tools_list(self):
+        """Test that as_tool() result can be added to another agent's tools."""
+        from praisonaiagents import Agent
+        from praisonaiagents.agent.handoff import Handoff
+        
+        # Create specialist agents
+        researcher = Agent(name="Researcher", instructions="Research topics")
+        coder = Agent(name="Coder", instructions="Write code")
+        
+        # Create parent agent with specialists as tools
+        writer = Agent(
+            name="Writer",
+            instructions="Write articles using your tools",
+            tools=[
+                researcher.as_tool("Research a topic"),
+                coder.as_tool("Write Python code"),
+            ],
+        )
+        
+        # Verify tools were added (they get converted to tool functions)
+        # The handoffs should be processed into the tools list
+        assert writer.name == "Writer"
+        # Note: Handoffs are processed in _process_handoffs, so we check the agent was created