autobyteus 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

autobyteus/agent/async_agent.py

@@ -1,175 +0,0 @@
-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

@@ -1,136 +0,0 @@
-
-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/group/async_group_aware_agent.py

@@ -1,122 +0,0 @@
-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}")

autobyteus/agent/group/coordinator_agent.py

@@ -1,36 +0,0 @@
-# File: autobyteus/agent/group/coordinator_agent.py
-
-import asyncio
-import os
-import logging
-from autobyteus.agent.group.group_aware_agent import GroupAwareAgent, AgentStatus
-from autobyteus.agent.message.message_types import MessageType
-from autobyteus.agent.message.message import Message
-
-from autobyteus.events.event_types import EventType
-from autobyteus.prompt.prompt_builder import PromptBuilder
-from autobyteus.llm.base_llm import BaseLLM
-from typing import List
-from autobyteus.tools.base_tool import BaseTool
-
-logger = logging.getLogger(__name__)
-
-class CoordinatorAgent(GroupAwareAgent):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        logger.info(f"CoordinatorAgent initialized with role: {self.role}")
-
-
-    async def process_llm_response(self, llm_response):
-        """
-        Process the LLM response for the CoordinatorAgent.
-        """
-        logger.info(f"CoordinatorAgent {self.role} processing LLM response")
-        tool_invocation = self.response_parser.parse_response(llm_response)
-
-        if tool_invocation.is_valid():
-            await self.execute_tool(tool_invocation)
-        else:
-            logger.info(f"Coordinator Response for agent {self.role}: {llm_response}")
-            logger.info(f"CoordinatorAgent {self.role} task completed, emitting TASK_COMPLETED event")
-            self.emit(EventType.TASK_COMPLETED)

autobyteus/agent/group/group_aware_agent.py

@@ -1,121 +0,0 @@
-import asyncio
-import logging
-from autobyteus.agent.agent import Agent, AgentStatus
-from autobyteus.agent.message.send_message_to import SendMessageTo
-from autobyteus.events.event_types import EventType
-from autobyteus.agent.message.message_types import MessageType
-from autobyteus.agent.message.message import Message
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from autobyteus.agent.orchestrator.base_agent_orchestrator import BaseAgentOrchestrator
-
-logger = logging.getLogger(__name__)
-
-class GroupAwareAgent(Agent):
-    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"GroupAwareAgent initialized with role: {self.role}")
-
-    def _initialize_queues(self):
-        if not self._queues_initialized:
-            self.tool_result_messages = asyncio.Queue()
-            self.user_messages = asyncio.Queue()
-            self._queues_initialized = True
-            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:
-            logger.warning(f"Agent {self.agent_id} received message before queues were initialized. Initializing now.")
-            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)
-                
-                llm_response = await self.conversation.send_user_message(f"Message from sender_agent_id {message.sender_agent_id}, content {message.content}")
-                await self.process_llm_response(llm_response)
-            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 group-aware agent: {self.role}")

autobyteus/agent/orchestrator/base_agent_orchestrator.py

@@ -1,82 +0,0 @@
-from abc import ABC, abstractmethod
-import logging
-from typing import Dict, Optional
-from autobyteus.agent.exceptions import AgentNotFoundException
-from autobyteus.agent.group.group_aware_agent import GroupAwareAgent
-from autobyteus.agent.message.message import Message
-from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.events.event_types import EventType
-
-logger = logging.getLogger(__name__)
-
-class BaseAgentOrchestrator(EventEmitter):
-    def __init__(self):
-        super().__init__()
-        self.agents: Dict[str, GroupAwareAgent] = {}  # Keyed by agent_id
-        self.coordinator_agent = None
-
-    @abstractmethod
-    def add_agent(self, agent: GroupAwareAgent):
-        pass
-
-    @abstractmethod
-    def get_agent(self, agent_id: str) -> Optional[GroupAwareAgent]:
-        pass
-
-    @abstractmethod
-    def create_agent_if_needed(self, role: str) -> GroupAwareAgent:
-        pass
-    
-    def set_coordinator_agent(self, agent: GroupAwareAgent):
-        self.coordinator_agent = agent
-        self.add_agent(agent)
-
-    async def route_message(self, message: Message):
-        target_agent = None
-        if message.recipient_agent_id != "unknown":
-            target_agent = self.get_agent(message.recipient_agent_id)
-            if not target_agent:
-                raise AgentNotFoundException(message.recipient_agent_id)
-        else:
-            target_agent = self.create_agent_if_needed(message.recipient_role_name)
-            
-        if not target_agent:
-            logger.error(f"Unable to find or create agent for role: {message.recipient_role_name}")
-            return None
-
-        logger.info(f"Routing message: from={message.sender_agent_id}, to={message.recipient_role_name} (id={target_agent.agent_id})")
-        return await target_agent.receive_agent_message(message)
-
-    def start_agent(self, agent: GroupAwareAgent):
-        self.add_agent(agent)
-        agent.start()
-
-    def remove_agent(self, agent_id: str):
-        if agent_id in self.agents:
-            agent = self.agents[agent_id]
-            del self.agents[agent_id]
-            logger.info(f"Agent removed: role={agent.role}, id={agent_id}")
-
-    def handle_task_completed(self, agent_id: str):
-        """
-        Handle task completion for a specific agent. This emits the event directly to the target agent,
-        ensuring only the relevant agent receives the completion notification.
-        """
-        logger.info(f"Handling task completion for agent: {agent_id}")
-        #self.remove_agent(agent_id)
-        
-        # Get the target agent
-        target_agent = self.get_agent(agent_id)
-        if target_agent:
-            # Emit the event directly to the target agent
-            self.emit(EventType.TASK_COMPLETED, target=target_agent)
-        else:
-            logger.warning(f"Could not find agent {agent_id} to notify of task completion")
-
-    @abstractmethod
-    async def run(self):
-        pass
-
-    @abstractmethod
-    async def cleanup(self):
-        pass