autobyteus 1.0.0__py3-none-any.whl

autobyteus/__init__.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+import sys
+
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))

autobyteus/agent/agent.py

@@ -0,0 +1,231 @@
+import asyncio
+import logging
+from typing import List, Optional
+from autobyteus.agent.response_parser.tool_usage_command_parser import ToolUsageCommandParser
+from autobyteus.events.event_emitter import EventEmitter
+from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.prompt.prompt_builder import PromptBuilder
+from autobyteus.events.event_types import EventType
+from autobyteus.agent.status import AgentStatus
+from autobyteus.conversation.user_message import UserMessage
+from autobyteus.conversation.conversation import Conversation
+
+logger = logging.getLogger(__name__)
+
+class Agent(EventEmitter):
+    def __init__(self, role: str, llm: BaseLLM, tools: Optional[List[BaseTool]] = None,
+                 agent_id=None,
+                 prompt_builder: Optional[PromptBuilder] = None,
+                 initial_user_message: Optional[UserMessage] = None):
+        super().__init__()
+        self.role = role
+        self.llm = llm
+        self.tools = tools or []
+        self.tool_usage_response_parser = ToolUsageCommandParser() if self.tools else None
+        self.conversation = None
+        self.agent_id = agent_id or f"{self.role}-001"
+        self.status = AgentStatus.NOT_STARTED
+        self._run_task = None
+        self._queues_initialized = False
+        self.task_completed = None
+        self.prompt_builder = prompt_builder
+        self.initial_user_message = initial_user_message
+
+        if not self.prompt_builder and not self.initial_user_message:
+            raise ValueError("Either prompt_builder or initial_user_message must be provided")
+
+        if self.tools:
+            self.set_agent_id_on_tools()
+            
+        logger.info(f"StandaloneAgent initialized with role: {self.role}, agent_id: {self.agent_id}")
+
+    def _initialize_queues(self):
+        if not self._queues_initialized:
+            self.tool_result_messages = asyncio.Queue()
+            self.user_messages = asyncio.Queue()
+            self._queues_initialized = True
+            logger.info(f"Queues initialized for agent {self.role}")
+
+    def _initialize_task_completed(self):
+        if self.task_completed is None:
+            self.task_completed = asyncio.Event()
+            logger.info(f"task_completed Event initialized for agent {self.role}")
+
+    def get_task_completed(self):
+        if self.task_completed is None:
+            raise RuntimeError("task_completed Event accessed before initialization")
+        return self.task_completed
+
+    async def run(self):
+        try:
+            logger.info(f"Starting execution for agent: {self.role}")
+            self._initialize_queues()
+            self._initialize_task_completed()
+            await self.initialize_conversation()
+
+            user_message_handler = asyncio.create_task(self.handle_user_messages())
+            tool_result_handler = asyncio.create_task(self.handle_tool_result_messages())
+
+            # Once everything is ready, set the status to RUNNING
+            self.status = AgentStatus.RUNNING
+
+            await asyncio.gather(user_message_handler, tool_result_handler)
+
+        except Exception as e:
+            logger.error(f"Error in agent {self.role} execution: {str(e)}")
+            self.status = AgentStatus.ERROR
+        finally:
+            self.status = AgentStatus.ENDED
+            await self.cleanup()
+
+    async def handle_user_messages(self):
+        logger.info(f"Agent {self.role} started handling user messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                user_message: UserMessage = await asyncio.wait_for(self.user_messages.get(), timeout=1.0)
+                logger.info(f"Agent {self.role} handling user message")
+                response = await self.conversation.send_user_message(user_message.content, user_message.file_paths)
+                await self.process_llm_response(response)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"User message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling user message for agent {self.role}: {str(e)}")
+
+    async def receive_user_message(self, message: UserMessage):
+        """
+        This method gracefully waits for the agent to become RUNNING
+        if it's in the process of starting up, ensuring the queues are
+        initialized before we put a message into them.
+        """
+        logger.info(f"Agent {self.agent_id} received user message")
+
+        # If the agent is not started (or ended), begin the start process
+        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
+            self.start()
+
+        # If the agent is still starting, wait until it transitions to RUNNING
+        while self.status == AgentStatus.STARTING:
+            await asyncio.sleep(0.1)
+
+        if self.status != AgentStatus.RUNNING:
+            logger.error(f"Agent is not in a running state: {self.status}")
+            return
+
+        # Now that we are running, safely place the message in the queue
+        await self.user_messages.put(message)
+
+    async def handle_tool_result_messages(self):
+        logger.info(f"Agent {self.role} started handling tool result messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message = await asyncio.wait_for(self.tool_result_messages.get(), timeout=1.0)
+                logger.info(f"Agent {self.role} handling tool result message: {message}")
+                response = await self.conversation.send_user_message(f"Tool execution result: {message}")
+                await self.process_llm_response(response)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Tool result handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling tool result for agent {self.role}: {str(e)}")
+
+    async def initialize_conversation(self):
+        logger.info(f"Initializing conversation for agent: {self.role}")
+        self.conversation = Conversation(self.llm)
+
+        if self.initial_user_message:
+            initial_message = self.initial_user_message
+        else:
+            prompt_content = self.prompt_builder.set_variable_value(
+                "external_tools", 
+                self._get_external_tools_section()
+            ).build()
+            initial_message = UserMessage(content=prompt_content)
+
+        logger.debug(f"Initial user message for agent {self.role}: {initial_message}")
+        initial_llm_response = await self.conversation.send_user_message(
+            initial_message.content,
+            initial_message.file_paths
+        )
+        await self.process_llm_response(initial_llm_response)
+
+    async def process_llm_response(self, response: str) -> None:
+        self.emit(EventType.ASSISTANT_RESPONSE, response=response)
+        
+        if self.tools and self.tool_usage_response_parser:
+            tool_invocation = self.tool_usage_response_parser.parse_response(response)
+            if tool_invocation.is_valid():
+                await self.execute_tool(tool_invocation)
+                return
+
+        logger.info(f"Assistant response for agent {self.role}: {response}")
+
+    async def execute_tool(self, tool_invocation):
+        name = tool_invocation.name
+        arguments = tool_invocation.arguments
+        logger.info(f"Agent {self.role} attempting to execute tool: {name}")
+
+        tool = next((t for t in self.tools if t.get_name() == name), None)
+        if tool:
+            try:
+                result = await tool.execute(**arguments)
+                logger.info(f"Tool '{name}' executed successfully by agent {self.role}. Result: {result}")
+                await self.tool_result_messages.put(result)
+            except Exception as e:
+                error_message = str(e)
+                logger.error(f"Error executing tool '{name}' by agent {self.role}: {error_message}")
+                await self.tool_result_messages.put(f"Error: {error_message}")
+        else:
+            logger.warning(f"Tool '{name}' not found for agent {self.role}.")
+
+    def start(self):
+        """
+        Starts the agent by creating a task that runs the main loop (run).
+        Sets the AgentStatus to STARTING to prevent message enqueuing before
+        the system is fully initialized.
+        """
+        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
+            logger.info(f"Starting agent {self.role}")
+            self.status = AgentStatus.STARTING
+            self._run_task = asyncio.create_task(self.run())
+        elif self.status == AgentStatus.STARTING:
+            logger.info(f"Agent {self.role} is already in STARTING state.")
+        elif self.status == AgentStatus.RUNNING:
+            logger.info(f"Agent {self.role} is already running.")
+        else:
+            logger.warning(f"Agent {self.role} is in an unexpected state: {self.status}")
+
+    def stop(self):
+        if self._run_task and not self._run_task.done():
+            self._run_task.cancel()
+
+    async def cleanup(self):
+        while not self.tool_result_messages.empty():
+            self.tool_result_messages.get_nowait()
+        while not self.user_messages.empty():
+            self.user_messages.get_nowait()
+        await self.llm.cleanup()
+        logger.info(f"Cleanup completed for agent: {self.role}")
+
+    def set_agent_id_on_tools(self):
+        if self.tools:
+            for tool in self.tools:
+                tool.set_agent_id(self.agent_id)
+
+    def _get_external_tools_section(self) -> str:
+        if not self.tools:
+            return ""
+            
+        external_tools_section = ""
+        for i, tool in enumerate(self.tools):
+            external_tools_section += f"  {i + 1} {tool.tool_usage_xml()}\n\n"
+        return external_tools_section.strip()
+
+    def on_task_completed(self, *args, **kwargs):
+        logger.info(f"Task completed event received for agent: {self.role}")
+        self.task_completed.set()

autobyteus/agent/async_agent.py

@@ -0,0 +1,175 @@
+import asyncio
+import logging
+from typing import (
+    List, 
+    Optional, 
+    AsyncGenerator, 
+    Any, 
+    NoReturn,
+    Union,
+    AsyncIterator
+)
+from autobyteus.agent.agent import Agent
+from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.prompt.prompt_builder import PromptBuilder
+from autobyteus.events.event_types import EventType
+from autobyteus.agent.status import AgentStatus
+from autobyteus.conversation.user_message import UserMessage
+from autobyteus.conversation.conversation import Conversation
+from autobyteus.agent.tool_invocation import ToolInvocation
+
+logger = logging.getLogger(__name__)
+
+class AsyncAgent(Agent):
+    """
+    An asynchronous agent that supports streaming LLM responses while maintaining
+    compatibility with the base agent functionality.
+    """
+    
+    def __init__(
+        self, 
+        role: str, 
+        llm: BaseLLM, 
+        tools: Optional[List[BaseTool]] = None,
+        agent_id: Optional[str] = None,
+        prompt_builder: Optional[PromptBuilder] = None,
+        initial_user_message: Optional[UserMessage] = None
+    ) -> None:
+        """
+        Initialize the AsyncAgent with the given parameters.
+
+        Args:
+            role: The role of the agent
+            llm: The language model instance
+            tools: List of available tools
+            use_xml_parser: Whether to use XML parser for responses
+            agent_id: Optional unique identifier for the agent
+            prompt_builder: Optional prompt builder instance
+            initial_user_message: Optional initial message to start the conversation
+        """
+        super().__init__(
+            role, 
+            llm, 
+            tools, 
+            agent_id, 
+            prompt_builder, 
+            initial_user_message
+        )
+
+    async def initialize_conversation(self) -> None:
+        """Initialize the conversation with initial message or prompt."""
+        logger.info(f"Initializing conversation for agent: {self.role}")
+        self.conversation = Conversation(self.llm)
+
+        if self.initial_user_message:
+            initial_message = self.initial_user_message
+        else:
+            prompt_content = self.prompt_builder.set_variable_value(
+                "external_tools", 
+                self._get_external_tools_section()
+            ).build()
+            initial_message = UserMessage(content=prompt_content)
+
+        logger.debug(f"Initial user message for agent {self.role}: {initial_message}")
+        await self.process_streaming_response(
+            self.conversation.stream_user_message(
+                initial_message.content, 
+                initial_message.file_paths
+            )
+        )
+
+    async def handle_user_messages(self) -> NoReturn:
+        """
+        Handle incoming user messages continuously.
+        Processes messages using streaming responses.
+        """
+        logger.info(f"Agent {self.role} started handling user messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                user_message: UserMessage = await asyncio.wait_for(
+                    self.user_messages.get(), 
+                    timeout=1.0
+                )
+                logger.info(f"Agent {self.role} handling user message")
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        user_message.content, 
+                        user_message.file_paths
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"User message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling user message for agent {self.role}: {str(e)}")
+
+    async def handle_tool_result_messages(self) -> NoReturn:
+        """
+        Handle tool execution result messages continuously.
+        Processes messages using streaming responses.
+        """
+        logger.info(f"Agent {self.role} started handling tool result messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message: str = await asyncio.wait_for(
+                    self.tool_result_messages.get(), 
+                    timeout=1.0
+                )
+                logger.info(f"Agent {self.role} handling tool result message: {message}")
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        f"Tool execution result: {message}"
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Tool result handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling tool result for agent {self.role}: {str(e)}")
+
+    async def process_streaming_response(
+        self, 
+        response_stream: AsyncIterator[str]
+    ) -> None:
+        """
+        Process streaming responses from the LLM, emitting each chunk and handling
+        tool invocations after receiving the complete response.
+        
+        Args:
+            response_stream: AsyncIterator yielding response tokens
+        """
+        complete_response: str = ""
+        try:
+            async for chunk in response_stream:
+                # Emit each chunk as it arrives
+                self.emit(
+                    EventType.ASSISTANT_RESPONSE, 
+                    response=chunk,
+                    is_complete=False
+                )
+                complete_response += chunk
+            # Emit the complete response
+            self.emit(
+                EventType.ASSISTANT_RESPONSE, 
+                response=complete_response,
+                is_complete=True
+            )
+
+            if self.tools and self.tool_usage_response_parser:
+                tool_invocation: ToolInvocation = self.tool_usage_response_parser.parse_response(complete_response)
+                if tool_invocation.is_valid():
+                    await self.execute_tool(tool_invocation)
+                    return
+
+            logger.info(f"Assistant response for agent {self.role}: {complete_response}")
+
+        except Exception as e:
+            logger.error(f"Error processing streaming response for agent {self.role}: {str(e)}")
+            self.emit(
+                EventType.ERROR,
+                error=str(e))

autobyteus/agent/async_group_aware_agent.py

@@ -0,0 +1,136 @@
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Optional, AsyncIterator
+from autobyteus.agent.async_agent import AsyncAgent
+from autobyteus.agent.message.message import Message
+from autobyteus.agent.message.message_types import MessageType
+from autobyteus.agent.message.send_message_to import SendMessageTo
+from autobyteus.agent.status import AgentStatus
+from autobyteus.events.event_types import EventType
+
+if TYPE_CHECKING:
+    from autobyteus.agent.orchestrator.base_agent_orchestrator import BaseAgentOrchestrator
+
+logger = logging.getLogger(__name__)
+
+class AsyncGroupAwareAgent(AsyncAgent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.agent_orchestrator: Optional['BaseAgentOrchestrator'] = None
+        self.incoming_agent_messages: Optional[asyncio.Queue] = None
+        logger.info(f"AsyncGroupAwareAgent initialized with role: {self.role}")
+
+    def _initialize_queues(self):
+        if not self._queues_initialized:
+            super()._initialize_queues()
+            self.incoming_agent_messages = asyncio.Queue()
+            logger.info(f"Queues initialized for agent {self.role}")
+
+    def set_agent_orchestrator(self, agent_orchestrator: 'BaseAgentOrchestrator'):
+        self.agent_orchestrator = agent_orchestrator
+        if not any(isinstance(tool, SendMessageTo) for tool in self.tools):
+            self.tools.append(SendMessageTo(agent_orchestrator))
+        self.register_task_completion_listener()
+        logger.info(f"Agent orchestrator set for agent {self.role}")
+
+    def register_task_completion_listener(self):
+        """Register to listen for task completion events from the orchestrator specifically"""
+        logger.info(f"Registering task completion listener for agent: {self.role}")
+        if self.agent_orchestrator:
+            self.subscribe_from(
+                self.agent_orchestrator, 
+                EventType.TASK_COMPLETED,
+                self.on_task_completed
+            )
+        else:
+            logger.warning(f"Cannot register task completion listener for agent {self.role}: orchestrator not set")
+
+    async def receive_agent_message(self, message: Message):
+        logger.info(f"Agent {self.agent_id} received message from {message.sender_agent_id}")
+        if not self._queues_initialized:
+            self._initialize_queues()
+        await self.incoming_agent_messages.put(message)
+        if self.status != AgentStatus.RUNNING:
+            self.start()
+
+    async def run(self):
+        try:
+            logger.info(f"Agent {self.role} entering running state")
+            self._initialize_queues()
+            self._initialize_task_completed()
+            await self.initialize_conversation()
+        
+            self.status = AgentStatus.RUNNING
+            
+            user_message_handler = asyncio.create_task(self.handle_user_messages())
+            tool_result_handler = asyncio.create_task(self.handle_tool_result_messages())
+            agent_message_handler = asyncio.create_task(self.handle_agent_messages())
+            
+            done, pending = await asyncio.wait(
+                [agent_message_handler, tool_result_handler, user_message_handler, self.task_completed.wait()],
+                return_when=asyncio.FIRST_COMPLETED
+            )
+
+            for task in pending:
+                task.cancel()
+
+            await asyncio.gather(*pending, return_exceptions=True)
+
+        except Exception as e:
+            logger.error(f"Error in agent {self.role} execution: {str(e)}")
+            self.status = AgentStatus.ERROR
+        finally:
+            self.status = AgentStatus.ENDED
+            await self.cleanup()
+
+    async def handle_agent_messages(self):
+        logger.info(f"Agent {self.role} started handling agent messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message = await asyncio.wait_for(self.incoming_agent_messages.get(), timeout=1.0)
+                logger.info(f"{self.role} processing message from {message.sender_agent_id}")
+                
+                if message.message_type == MessageType.TASK_RESULT:
+                    self.agent_orchestrator.handle_task_completed(message.sender_agent_id)
+                
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        f"Message from sender_agent_id {message.sender_agent_id}, content {message.content}"
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Agent message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling agent message for agent {self.role}: {str(e)}")
+
+    async def execute_tool(self, tool_invocation):
+        name = tool_invocation.name
+        arguments = tool_invocation.arguments
+        logger.info(f"Agent {self.role} attempting to execute tool: {name}")
+
+        tool = next((t for t in self.tools if t.get_name() == name), None)
+        if tool:
+            try:
+                result = await tool.execute(**arguments)
+                logger.info(f"Tool '{name}' executed successfully by agent {self.role}. Result: {result}")
+                if not isinstance(tool, SendMessageTo):
+                    await self.tool_result_messages.put(result)
+                else:
+                    logger.info(f"SendMessageTo tool executed by agent {self.role}: {result}")
+            except Exception as e:
+                error_message = str(e)
+                logger.error(f"Error executing tool '{name}' by agent {self.role}: {error_message}")
+                if not isinstance(tool, SendMessageTo):
+                    await self.tool_result_messages.put(f"Error: {error_message}")
+        else:
+            logger.warning(f"Tool '{name}' not found for agent {self.role}.")
+
+    async def cleanup(self):
+        await super().cleanup()
+        while not self.incoming_agent_messages.empty():
+            self.incoming_agent_messages.get_nowait()
+        logger.info(f"Cleanup completed for async group-aware agent: {self.role}")

autobyteus/agent/exceptions.py

@@ -0,0 +1,6 @@
+# File: autobyteus/exceptions.py
+
+class AgentNotFoundException(Exception):
+    def __init__(self, agent_id: str):
+        super().__init__(f"Agent with id {agent_id} not found. This is an invalid state.")
+        self.agent_id = agent_id

autobyteus/agent/group/async_group_aware_agent.py

@@ -0,0 +1,122 @@
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Optional, AsyncIterator
+from autobyteus.agent.async_agent import AsyncAgent
+from autobyteus.agent.message.message import Message
+from autobyteus.agent.message.message_types import MessageType
+from autobyteus.agent.message.send_message_to import SendMessageTo
+from autobyteus.agent.status import AgentStatus
+from autobyteus.events.event_types import EventType
+
+if TYPE_CHECKING:
+    from autobyteus.agent.orchestrator.base_agent_orchestrator import BaseAgentOrchestrator
+
+logger = logging.getLogger(__name__)
+
+class AsyncGroupAwareAgent(AsyncAgent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.agent_orchestrator: Optional['BaseAgentOrchestrator'] = None
+        self.incoming_agent_messages: Optional[asyncio.Queue] = None
+        logger.info(f"AsyncGroupAwareAgent initialized with role: {self.role}")
+
+    def _initialize_queues(self):
+        if not self._queues_initialized:
+            super()._initialize_queues()
+            self.incoming_agent_messages = asyncio.Queue()
+            logger.info(f"Queues initialized for agent {self.role}")
+
+    def set_agent_orchestrator(self, agent_orchestrator: 'BaseAgentOrchestrator'):
+        self.agent_orchestrator = agent_orchestrator
+        if not any(isinstance(tool, SendMessageTo) for tool in self.tools):
+            self.tools.append(SendMessageTo(agent_orchestrator))
+        logger.info(f"Agent orchestrator set for agent {self.role}")
+
+    async def receive_agent_message(self, message: Message):
+        logger.info(f"Agent {self.agent_id} received message from {message.sender_agent_id}")
+        if not self._queues_initialized:
+            self._initialize_queues()
+        await self.incoming_agent_messages.put(message)
+        if self.status != AgentStatus.RUNNING:
+            self.start()
+
+    async def run(self):
+        try:
+            logger.info(f"Agent {self.role} entering running state")
+            self._initialize_queues()
+            self._initialize_task_completed()
+            await self.initialize_conversation()
+        
+            self.status = AgentStatus.RUNNING
+            
+            user_message_handler = asyncio.create_task(self.handle_user_messages())
+            tool_result_handler = asyncio.create_task(self.handle_tool_result_messages())
+            agent_message_handler = asyncio.create_task(self.handle_agent_messages())
+            
+            done, pending = await asyncio.wait(
+                [agent_message_handler, tool_result_handler, user_message_handler, self.task_completed.wait()],
+                return_when=asyncio.FIRST_COMPLETED
+            )
+
+            for task in pending:
+                task.cancel()
+
+            await asyncio.gather(*pending, return_exceptions=True)
+
+        except Exception as e:
+            logger.error(f"Error in agent {self.role} execution: {str(e)}")
+            self.status = AgentStatus.ERROR
+        finally:
+            self.status = AgentStatus.ENDED
+            await self.cleanup()
+
+    async def handle_agent_messages(self):
+        logger.info(f"Agent {self.role} started handling agent messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message = await asyncio.wait_for(self.incoming_agent_messages.get(), timeout=1.0)
+                logger.info(f"{self.role} processing message from {message.sender_agent_id}")
+                
+                if message.message_type == MessageType.TASK_RESULT:
+                    self.agent_orchestrator.handle_task_completed(message.sender_agent_id)
+                
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        f"Message from sender_agent_id {message.sender_agent_id}, content {message.content}"
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Agent message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling agent message for agent {self.role}: {str(e)}")
+
+    async def execute_tool(self, tool_invocation):
+        name = tool_invocation.name
+        arguments = tool_invocation.arguments
+        logger.info(f"Agent {self.role} attempting to execute tool: {name}")
+
+        tool = next((t for t in self.tools if t.get_name() == name), None)
+        if tool:
+            try:
+                result = await tool.execute(**arguments)
+                logger.info(f"Tool '{name}' executed successfully by agent {self.role}. Result: {result}")
+                if not isinstance(tool, SendMessageTo):
+                    await self.tool_result_messages.put(result)
+                else:
+                    logger.info(f"SendMessageTo tool executed by agent {self.role}: {result}")
+            except Exception as e:
+                error_message = str(e)
+                logger.error(f"Error executing tool '{name}' by agent {self.role}: {error_message}")
+                if not isinstance(tool, SendMessageTo):
+                    await self.tool_result_messages.put(f"Error: {error_message}")
+        else:
+            logger.warning(f"Tool '{name}' not found for agent {self.role}.")
+
+    async def cleanup(self):
+        await super().cleanup()
+        while not self.incoming_agent_messages.empty():
+            self.incoming_agent_messages.get_nowait()
+        logger.info(f"Cleanup completed for async group-aware agent: {self.role}")