autobyteus 1.1.3__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/agent/group/agent_group_context.py

@@ -1,81 +0,0 @@
-# file: autobyteus/autobyteus/agent/group/agent_group_context.py
-import logging
-from typing import List, Dict, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.agent.agent import Agent 
-
-logger = logging.getLogger(__name__)
-
-class AgentGroupContext:
-    """
-    Stores contextual information about an agent group, including its ID,
-    member agents, and the designated coordinator. Provides methods to
-    discover agents within the group.
-    """
-    def __init__(self,
-                 group_id: str,
-                 agents: List['Agent'],
-                 coordinator_agent_id: str):
-        """
-        Initializes the AgentGroupContext.
-        """
-        if not group_id or not isinstance(group_id, str):
-            raise ValueError("AgentGroupContext requires a non-empty string 'group_id'.")
-        if not coordinator_agent_id or not isinstance(coordinator_agent_id, str):
-            raise ValueError("AgentGroupContext requires a non-empty string 'coordinator_agent_id'.")
-        if not agents:
-            raise ValueError("AgentGroupContext requires a non-empty list of 'agents'.")
-
-        from autobyteus.agent.agent import Agent as AgentClassRef
-        if not all(isinstance(agent, AgentClassRef) for agent in agents):
-            raise TypeError("All items in 'agents' list must be instances of the 'Agent' class.")
-
-        self.group_id: str = group_id
-        self._agents_by_id: Dict[str, 'Agent'] = {agent.agent_id: agent for agent in agents}
-        self._coordinator_agent_id: str = coordinator_agent_id
-
-        if self._coordinator_agent_id not in self._agents_by_id:
-            logger.error(f"Coordinator agent with ID '{self._coordinator_agent_id}' not found in the provided list of agents for group '{self.group_id}'.")
-        
-        logger.info(f"AgentGroupContext initialized for group_id '{self.group_id}'.")
-
-    def get_agent(self, agent_id: str) -> Optional['Agent']:
-        """
-        Retrieves an agent from the group by its unique agent_id.
-        """
-        return self._agents_by_id.get(agent_id)
-
-    def get_agents_by_role(self, role_name: str) -> List['Agent']:
-        """
-        Retrieves all agents within the group that match the specified role name.
-        """
-        if not isinstance(role_name, str):
-            logger.warning(f"Attempted to get_agents_by_role with non-string role_name: {role_name} in group '{self.group_id}'.")
-            return []
-            
-        matching_agents: List['Agent'] = [
-            agent for agent in self._agents_by_id.values()
-            if agent.context and agent.context.config and agent.context.config.role == role_name
-        ]
-        
-        if not matching_agents:
-            logger.debug(f"No agents found with role '{role_name}' in group '{self.group_id}'.")
-        return matching_agents
-
-    def get_coordinator_agent(self) -> Optional['Agent']:
-        """
-        Retrieves the designated coordinator agent for this group.
-        """
-        return self.get_agent(self._coordinator_agent_id)
-
-    def get_all_agents(self) -> List['Agent']:
-        """
-        Retrieves all agents currently part of this group.
-        """
-        return list(self._agents_by_id.values())
-
-    def __repr__(self) -> str:
-        return (f"<AgentGroupContext group_id='{self.group_id}', "
-                f"num_agents={len(self._agents_by_id)}, "
-                f"coordinator_id='{self._coordinator_agent_id}'>")

autobyteus/agent/input_processor/content_prefixing_input_processor.py

@@ -1,41 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/content_prefixing_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class ContentPrefixingInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that adds a predefined prefix to the message content.
-    The prefix is defined by the agent's custom_data (in AgentRuntimeState) or a default.
-    Example prefix key in custom_data: "content_prefix"
-    """
-    DEFAULT_PREFIX = "[Processed Message] "
-
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by prefixing its content.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id # Convenience property
-        logger.debug(f"Agent '{agent_id}': ContentPrefixingInputProcessor processing message.")
-        
-        # Access custom_data via convenience property (or context.state.custom_data)
-        prefix = context.custom_data.get("content_prefix", self.DEFAULT_PREFIX)
-        if not isinstance(prefix, str):
-            logger.warning(f"Agent '{agent_id}': 'content_prefix' in custom_data is not a string. Using default prefix. Found: {type(prefix)}")
-            prefix = self.DEFAULT_PREFIX
-            
-        message.content = prefix + message.content
-        logger.info(f"Agent '{agent_id}': Prefixed message content with '{prefix}'.")
-        return message

autobyteus/agent/input_processor/metadata_appending_input_processor.py

@@ -1,34 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/metadata_appending_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class MetadataAppendingInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that appends fixed metadata to the message.
-    Example: Appends agent_id and config_name to metadata.
-    """
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by appending metadata.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id
-        config_name = context.config.name
-
-        logger.debug(f"Agent '{agent_id}': MetadataAppendingInputProcessor processing message.")
-        message.metadata["processed_by_agent_id"] = agent_id
-        message.metadata["processed_with_config_name"] = config_name
-        logger.info(f"Agent '{agent_id}': Appended 'processed_by_agent_id' and 'processed_with_config_name' to message metadata.")
-        return message

autobyteus/agent/input_processor/passthrough_input_processor.py

@@ -1,33 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/passthrough_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class PassthroughInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that returns the message unchanged.
-    Can be used as a default or for testing.
-    """
-    @classmethod
-    def get_name(cls) -> str:
-        return "PassthroughInputProcessor"
-
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by returning it without modification.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id # Convenience property
-        logger.debug(f"Agent '{agent_id}': PassthroughInputProcessor received message, returning as is.")
-        return message

autobyteus/agent/workflow/__init__.py

@@ -1,11 +0,0 @@
-# file: autobyteus/autobyteus/agent/workflow/__init__.py
-"""
-Components for defining and running agentic workflows.
-"""
-from .agentic_workflow import AgenticWorkflow
-from .base_agentic_workflow import BaseAgenticWorkflow
-
-__all__ = [
-    "AgenticWorkflow",
-    "BaseAgenticWorkflow",
-]

autobyteus/agent/workflow/agentic_workflow.py

@@ -1,89 +0,0 @@
-# file: autobyteus/autobyteus/agent/workflow/agentic_workflow.py
-import logging
-import uuid
-from typing import List, Dict, Optional, Any, cast
-
-from autobyteus.agent.context.agent_config import AgentConfig
-from autobyteus.agent.group.agent_group import AgentGroup
-
-logger = logging.getLogger(__name__)
-
-class AgenticWorkflow:
-    """
-    A concrete class for defining and running multi-agent workflows declaratively.
-    It internally manages an AgentGroup and provides a user-friendly interface
-    to process tasks.
-    """
-    def __init__(self,
-                 agent_configs: List[AgentConfig],
-                 coordinator_config_name: str,
-                 workflow_id: Optional[str] = None,
-                 input_param_name: str = "input",
-                ):
-        """
-        Initializes the AgenticWorkflow.
-
-        Args:
-            agent_configs: List of pre-made AgentConfig instances for the agents in this workflow.
-            coordinator_config_name: Name of the agent config to be used as coordinator.
-            workflow_id: Optional. A unique ID for this workflow instance. Auto-generated if None.
-            input_param_name: The key to use in `process(**kwargs)` to find the initial
-                              input string for the coordinator. Defaults to "input".
-        """
-        self.workflow_id: str = workflow_id or f"workflow_{uuid.uuid4()}"
-        self._input_param_name: str = input_param_name
-
-        logger.info(f"Initializing AgenticWorkflow '{self.workflow_id}'. "
-                    f"Input parameter name for process(): '{self._input_param_name}'.")
-
-        # The AgentGroup is now initialized directly with the user-provided configs.
-        self.agent_group: AgentGroup = AgentGroup(
-            agent_configs=agent_configs,
-            coordinator_config_name=coordinator_config_name,
-            group_id=f"group_for_{self.workflow_id}",
-        )
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' successfully instantiated internal AgentGroup '{self.agent_group.group_id}'.")
-
-    async def process(self, **kwargs: Any) -> Any:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received process request with kwargs: {list(kwargs.keys())}")
-
-        initial_input_content = kwargs.get(self._input_param_name)
-        if initial_input_content is None:
-            raise ValueError(f"Required input parameter '{self._input_param_name}' not found in process() arguments.")
-        if not isinstance(initial_input_content, str):
-            raise ValueError(f"Input parameter '{self._input_param_name}' must be a string, "
-                             f"got {type(initial_input_content).__name__}.")
-
-        user_id: Optional[str] = cast(Optional[str], kwargs.get("user_id")) if isinstance(kwargs.get("user_id"), str) else None
-        
-        logger.debug(f"AgenticWorkflow '{self.workflow_id}': Extracted initial input for coordinator: '{initial_input_content[:100]}...'")
-
-        result = await self.agent_group.process_task_for_coordinator(
-            initial_input_content=initial_input_content,
-            user_id=user_id
-        )
-        
-        return result
-
-
-    async def start(self) -> None:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received start() request. Delegating to AgentGroup.")
-        await self.agent_group.start()
-
-    async def stop(self, timeout: float = 10.0) -> None:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received stop() request. Delegating to AgentGroup.")
-        await self.agent_group.stop(timeout)
-
-    @property
-    def is_running(self) -> bool:
-        return self.agent_group.is_running
-
-    @property
-    def group_id(self) -> str:
-        return self.agent_group.group_id
-
-    def __repr__(self) -> str:
-        return (f"<AgenticWorkflow workflow_id='{self.workflow_id}', "
-                f"group_id='{self.agent_group.group_id}', "
-                f"coordinator='{self.agent_group.coordinator_config_name}', "
-                f"is_running={self.is_running}>")

autobyteus/tools/mcp/registrar.py

@@ -1,202 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/registrar.py
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-# Consolidated imports from the autobyteus.autobyteus.mcp package public API
-from .config_service import McpConfigService
-from .factory import McpToolFactory
-from .schema_mapper import McpSchemaMapper
-from .types import BaseMcpConfig, McpTransportType
-from .server import StdioManagedMcpServer, HttpManagedMcpServer, BaseManagedMcpServer
-
-from autobyteus.tools.registry import ToolRegistry, ToolDefinition
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.singleton import SingletonMeta
-from mcp import types as mcp_types
-
-
-logger = logging.getLogger(__name__)
-
-class McpToolRegistrar(metaclass=SingletonMeta):
-    """
-    Orchestrates the discovery of remote MCP tools and their registration
-    with the AutoByteUs ToolRegistry using a stateful, server-centric architecture.
-    """
-    def __init__(self):
-        """
-        Initializes the McpToolRegistrar singleton.
-        """
-        self._config_service: McpConfigService = McpConfigService()
-        self._tool_registry: ToolRegistry = ToolRegistry()
-        self._registered_tools_by_server: Dict[str, List[ToolDefinition]] = {}
-        logger.info("McpToolRegistrar initialized.")
-
-    def _create_server_instance_for_discovery(self, server_config: BaseMcpConfig) -> BaseManagedMcpServer:
-        """Creates a server instance based on transport type."""
-        if server_config.transport_type == McpTransportType.STDIO:
-            return StdioManagedMcpServer(server_config)
-        elif server_config.transport_type == McpTransportType.STREAMABLE_HTTP:
-            return HttpManagedMcpServer(server_config)
-        else:
-            raise NotImplementedError(f"Discovery not implemented for transport type: {server_config.transport_type}")
-
-    async def _fetch_tools_from_server(self, server_config: BaseMcpConfig) -> List[mcp_types.Tool]:
-        """
-        Creates a temporary server instance to perform a single, one-shot
-        tool discovery, ensuring resources are properly closed.
-        """
-        discovery_server = self._create_server_instance_for_discovery(server_config)
-        try:
-            # The list_remote_tools method implicitly handles the connection.
-            remote_tools = await discovery_server.list_remote_tools()
-            return remote_tools
-        finally:
-            # The finally block guarantees the temporary server connection is closed.
-            await discovery_server.close()
-
-    def _create_tool_definition_from_remote(
-        self,
-        remote_tool: mcp_types.Tool,
-        server_config: BaseMcpConfig,
-        schema_mapper: McpSchemaMapper
-    ) -> ToolDefinition:
-        """
-        Maps a single remote tool from an MCP server to an AutoByteUs ToolDefinition.
-        """
-        if hasattr(remote_tool, 'model_dump_json'):
-            logger.debug(f"Processing remote tool from server '{server_config.server_id}':\n{remote_tool.model_dump_json(indent=2)}")
-
-        actual_arg_schema = schema_mapper.map_to_autobyteus_schema(remote_tool.inputSchema)
-        actual_desc = remote_tool.description
-        
-        registered_name = remote_tool.name
-        if server_config.tool_name_prefix:
-            registered_name = f"{server_config.tool_name_prefix.rstrip('_')}_{remote_tool.name}"
-
-        # The factory now only needs key identifiers, not live objects.
-        tool_factory = McpToolFactory(
-            server_id=server_config.server_id,
-            remote_tool_name=remote_tool.name,
-            registered_tool_name=registered_name,
-            tool_description=actual_desc,
-            tool_argument_schema=actual_arg_schema
-        )
-        
-        return ToolDefinition(
-            name=registered_name,
-            description=actual_desc,
-            argument_schema=actual_arg_schema,
-            category=ToolCategory.MCP,
-            custom_factory=tool_factory.create_tool,
-            config_schema=None,
-            tool_class=None
-        )
-
-    async def discover_and_register_tools(self, mcp_config: Optional[Union[BaseMcpConfig, Dict[str, Any]]] = None) -> List[ToolDefinition]:
-        """
-        Discovers tools from MCP servers and registers them.
-        This process uses a helper to manage short-lived server instances for discovery.
-        """
-        configs_to_process: List[BaseMcpConfig]
-        
-        if mcp_config:
-            if isinstance(mcp_config, dict):
-                configs_to_process = [self._config_service.load_config(mcp_config)]
-            elif isinstance(mcp_config, BaseMcpConfig):
-                configs_to_process = [self._config_service.add_config(mcp_config)]
-            else:
-                raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-            logger.info(f"Starting targeted MCP tool discovery for server: {configs_to_process[0].server_id}")
-            self.unregister_tools_from_server(configs_to_process[0].server_id)
-        else:
-            logger.info("Starting full MCP tool discovery. Unregistering all existing MCP tools first.")
-            all_server_ids = list(self._registered_tools_by_server.keys())
-            for server_id in all_server_ids:
-                self.unregister_tools_from_server(server_id)
-            self._registered_tools_by_server.clear()
-            configs_to_process = self._config_service.get_all_configs()
-
-        if not configs_to_process:
-            logger.info("No MCP server configurations to process. Skipping discovery.")
-            return []
-
-        schema_mapper = McpSchemaMapper()
-        registered_tool_definitions: List[ToolDefinition] = []
-        for server_config in configs_to_process:
-            if not server_config.enabled:
-                logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
-                continue
-
-            logger.info(f"Discovering tools from MCP server: '{server_config.server_id}' ({server_config.transport_type.value})")
-            
-            try:
-                # The helper abstracts away the connect/close lifecycle for discovery.
-                remote_tools = await self._fetch_tools_from_server(server_config)
-                logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
-
-                for remote_tool in remote_tools:
-                    try:
-                        tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, schema_mapper)
-                        self._tool_registry.register_tool(tool_def)
-                        self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
-                        registered_tool_definitions.append(tool_def)
-                        logger.info(f"Successfully registered MCP tool '{remote_tool.name}' from server '{server_config.server_id}' as '{tool_def.name}'.")
-                    except Exception as e_tool:
-                        logger.error(f"Failed to process or register remote tool '{remote_tool.name}': {e_tool}", exc_info=True)
-            
-            except Exception as e_server:
-                logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
-        
-        logger.info(f"MCP tool discovery and registration process completed. Total tools registered: {len(registered_tool_definitions)}.")
-        return registered_tool_definitions
-
-    async def list_remote_tools(self, mcp_config: Union[BaseMcpConfig, Dict[str, Any]]) -> List[ToolDefinition]:
-        """
-        Previews tools from a remote MCP server without registering them.
-        This is a stateless "dry-run" or "preview" operation.
-        """
-        validated_config: BaseMcpConfig
-        if isinstance(mcp_config, dict):
-            validated_config = McpConfigService.parse_mcp_config_dict(mcp_config)
-        elif isinstance(mcp_config, BaseMcpConfig):
-            validated_config = mcp_config
-        else:
-            raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-        
-        logger.info(f"Previewing tools from MCP server: '{validated_config.server_id}' ({validated_config.transport_type.value})")
-        
-        schema_mapper = McpSchemaMapper()
-        tool_definitions: List[ToolDefinition] = []
-
-        try:
-            # Use the same helper to fetch tools, abstracting away the connection lifecycle.
-            remote_tools = await self._fetch_tools_from_server(validated_config)
-            logger.info(f"Discovered {len(remote_tools)} tools from server '{validated_config.server_id}' for preview.")
-
-            for remote_tool in remote_tools:
-                try:
-                    tool_def = self._create_tool_definition_from_remote(remote_tool, validated_config, schema_mapper)
-                    tool_definitions.append(tool_def)
-                except Exception as e_tool:
-                    logger.error(f"Failed to map remote tool '{remote_tool.name}' from server '{validated_config.server_id}' during preview: {e_tool}", exc_info=True)
-            
-        except Exception as e_server:
-            logger.error(f"Failed to discover tools for preview from MCP server '{validated_config.server_id}': {e_server}", exc_info=True)
-            raise
-            
-        logger.info(f"MCP tool preview completed. Found {len(tool_definitions)} tools.")
-        return tool_definitions
-
-    def unregister_tools_from_server(self, server_id: str) -> bool:
-        if not self.is_server_registered(server_id):
-            logger.info(f"No tools found for server ID '{server_id}'. Nothing to unregister.")
-            return False
-        tools_to_unregister = self._registered_tools_by_server.pop(server_id, [])
-        logger.info(f"Unregistering {len(tools_to_unregister)} tools from server ID: '{server_id}'...")
-        for tool_def in tools_to_unregister:
-            self._tool_registry.unregister_tool(tool_def.name)
-        logger.info(f"Successfully unregistered all tools and removed server '{server_id}' from registrar tracking.")
-        return True
-        
-    def is_server_registered(self, server_id: str) -> bool:
-        return server_id in self._registered_tools_by_server

autobyteus/workflow/simple_task.py

@@ -1,98 +0,0 @@
-import asyncio
-import logging
-from typing import Optional, Callable, Any, List, Union
-
-from autobyteus.agent.agent import Agent
-from autobyteus.events.event_types import EventType
-from autobyteus.llm.models import LLMModel
-from autobyteus.llm.llm_factory import LLMFactory
-from autobyteus.conversation.user_message import UserMessage
-
-logger = logging.getLogger(__name__)
-
-class SimpleTask:
-    """
-    A simplified task execution class for running single-instruction tasks
-    with minimal configuration and built-in result handling.
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        instruction: str,
-        llm_model: LLMModel,
-        input_data: Optional[Union[str, List[str]]] = None,
-        output_parser: Optional[Callable[[str], Any]] = None,
-    ):
-        """
-        Initialize a SimpleTask.
-
-        Args:
-            name (str): Name of the task
-            instruction (str): Task instruction/prompt
-            llm_model (LLMModel): LLM model to use
-            input_data (Optional[Union[str, List[str]]], optional): Input data or file paths. Defaults to None.
-            output_parser (Optional[Callable], optional): Function to parse the output. Defaults to None.
-        """
-        self.name = name
-        self.instruction = instruction
-        self.llm_model = llm_model
-        self.input_data = input_data if isinstance(input_data, list) else ([input_data] if input_data else [])
-        self.output_parser = output_parser
-        
-        logger.info(f"Initialized task '{self.name}' with model {self.llm_model.value} and {len(self.input_data)} inputs")
-
-    async def execute(self) -> Any:
-        """
-        Execute the task and return the result.
-
-        Returns:
-            The result of the task execution, parsed if output_parser is provided
-        """
-        try:
-            llm = LLMFactory.create_llm(self.llm_model)
-            
-            user_message = UserMessage(
-                content=self.instruction,
-                file_paths=self.input_data
-            )
-
-            agent = Agent(
-                role=self.name,
-                llm=llm,
-                initial_user_message=user_message
-            )
-
-            result_queue = asyncio.Queue()
-
-            async def handle_response(*args, **kwargs):
-                response = kwargs.get('response')
-                if response:
-                    await result_queue.put(response)
-
-            agent.subscribe(EventType.ASSISTANT_RESPONSE, handle_response, agent.agent_id)
-
-            try:
-                agent.start()
-                result = await asyncio.wait_for(
-                    result_queue.get(),
-                    timeout=30.0
-                )
-                
-                # Only parse if output_parser is provided
-                if self.output_parser:
-                    return self.output_parser(result)
-                return result
-
-            except asyncio.TimeoutError:
-                logger.error(f"Task '{self.name}' timed out")
-                raise TimeoutError(f"Task '{self.name}' execution timed out")
-
-            finally:
-                agent.unsubscribe("ASSISTANT_RESPONSE", handle_response, agent.agent_id)
-                agent.stop()
-                await agent.cleanup()
-
-        except Exception as e:
-            logger.error(f"Error executing task '{self.name}': {str(e)}")
-            raise