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

autobyteus/agent/context/agent_phase_manager.py

@@ -1,264 +0,0 @@
-# file: autobyteus/autobyteus/agent/context/agent_phase_manager.py
-import asyncio
-import logging
-from typing import TYPE_CHECKING, Optional, Dict, Any
-
-from autobyteus.agent.phases import AgentOperationalPhase, phase_transition
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context.agent_context import AgentContext
-    from autobyteus.agent.tool_invocation import ToolInvocation
-    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
-
-
-logger = logging.getLogger(__name__)
-
-class AgentPhaseManager:
-    """
-    Manages the operational phase of an agent, uses an AgentExternalEventNotifier
-    to signal phase changes externally, and executes phase transition hooks.
-    """
-    def __init__(self, context: 'AgentContext', notifier: 'AgentExternalEventNotifier'):
-        self.context: 'AgentContext' = context
-        self.notifier: 'AgentExternalEventNotifier' = notifier
-
-        self.context.current_phase = AgentOperationalPhase.UNINITIALIZED
-        
-        logger.debug(f"AgentPhaseManager initialized for agent_id '{self.context.agent_id}'. "
-                     f"Initial phase: {self.context.current_phase.value}. Uses provided notifier.")
-
-    async def _execute_hooks(self, old_phase: AgentOperationalPhase, new_phase: AgentOperationalPhase):
-        """Asynchronously executes hooks that match the given phase transition."""
-        hooks_to_run = [
-            hook for hook in self.context.config.phase_hooks
-            if hook.source_phase == old_phase and hook.target_phase == new_phase
-        ]
-
-        if not hooks_to_run:
-            return
-
-        hook_names = [hook.__class__.__name__ for hook in hooks_to_run]
-        logger.info(f"Agent '{self.context.agent_id}': Executing {len(hooks_to_run)} hooks for transition "
-                    f"'{old_phase.value}' -> '{new_phase.value}': {hook_names}")
-        
-        for hook in hooks_to_run:
-            try:
-                await hook.execute(self.context)
-                logger.debug(f"Agent '{self.context.agent_id}': Hook '{hook.__class__.__name__}' executed successfully.")
-            except Exception as e:
-                logger.error(f"Agent '{self.context.agent_id}': Error executing phase transition hook "
-                             f"'{hook.__class__.__name__}' for '{old_phase.value}' -> '{new_phase.value}': {e}",
-                             exc_info=True)
-                # We log the error but do not halt the agent's phase transition.
-
-    async def _transition_phase(self, new_phase: AgentOperationalPhase,
-                                notify_method_name: str,
-                                additional_data: Optional[Dict[str, Any]] = None):
-        """
-        Private async helper to change the agent's phase, execute hooks, and then
-        call the appropriate notifier method. Hooks are now awaited.
-        """
-        if not isinstance(new_phase, AgentOperationalPhase):
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}' received invalid type for new_phase: {type(new_phase)}. Must be AgentOperationalPhase.")
-            return
-
-        old_phase = self.context.current_phase
-        
-        if old_phase == new_phase:
-            logger.debug(f"AgentPhaseManager for '{self.context.agent_id}': already in phase {new_phase.value}. No transition.")
-            return
-
-        logger.info(f"Agent '{self.context.agent_id}' phase transitioning from {old_phase.value} to {new_phase.value}.")
-        self.context.current_phase = new_phase
-
-        # Execute and wait for hooks to complete *before* notifying externally.
-        await self._execute_hooks(old_phase, new_phase)
-
-        notifier_method = getattr(self.notifier, notify_method_name, None)
-        if notifier_method and callable(notifier_method):
-            notify_args = {"old_phase": old_phase}
-            if additional_data:
-                notify_args.update(additional_data)
-            
-            notifier_method(**notify_args)
-        else: 
-            logger.error(f"AgentPhaseManager for '{self.context.agent_id}': Notifier method '{notify_method_name}' not found or not callable on {type(self.notifier).__name__}.")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR],
-        target_phase=AgentOperationalPhase.UNINITIALIZED,
-        description="Triggered when the agent runtime is started or restarted after being in a terminal state."
-    )
-    async def notify_runtime_starting_and_uninitialized(self) -> None:
-        if self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        elif self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_runtime_starting_and_uninitialized called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.UNINITIALIZED],
-        target_phase=AgentOperationalPhase.BOOTSTRAPPING,
-        description="Occurs when the agent's internal bootstrapping process begins."
-    )
-    async def notify_bootstrapping_started(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.BOOTSTRAPPING, "notify_phase_bootstrapping_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.BOOTSTRAPPING],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when the agent successfully completes bootstrapping and is ready for input."
-    )
-    async def notify_initialization_complete(self) -> None:
-        if self.context.current_phase.is_initializing() or self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
-            # This will now be a BOOTSTRAPPING -> IDLE transition
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_initialization_complete called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.TOOL_DENIED
-        ],
-        target_phase=AgentOperationalPhase.PROCESSING_USER_INPUT,
-        description="Fires when the agent begins processing a new user message or inter-agent message."
-    )
-    async def notify_processing_input_started(self, trigger_info: Optional[str] = None) -> None:
-        if self.context.current_phase in [AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL, AgentOperationalPhase.TOOL_DENIED]:
-            data = {"trigger_info": trigger_info} if trigger_info else {}
-            await self._transition_phase(AgentOperationalPhase.PROCESSING_USER_INPUT, "notify_phase_processing_user_input_started", additional_data=data)
-        elif self.context.current_phase == AgentOperationalPhase.PROCESSING_USER_INPUT:
-             logger.debug(f"Agent '{self.context.agent_id}' already in PROCESSING_USER_INPUT phase.")
-        else:
-             logger.warning(f"Agent '{self.context.agent_id}' notify_processing_input_started called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.PROCESSING_TOOL_RESULT],
-        target_phase=AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-        description="Occurs just before the agent makes a call to the LLM."
-    )
-    async def notify_awaiting_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_LLM_RESPONSE, "notify_phase_awaiting_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-        description="Occurs after the agent has received a complete response from the LLM and begins to analyze it."
-    )
-    async def notify_analyzing_llm_response(self) -> None:
-        await self._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-        description="Occurs if the agent proposes a tool use that requires manual user approval."
-    )
-    async def notify_tool_execution_pending_approval(self, tool_invocation: 'ToolInvocation') -> None:
-        await self._transition_phase(AgentOperationalPhase.AWAITING_TOOL_APPROVAL, "notify_phase_awaiting_tool_approval_started")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs after a pending tool use has been approved and is about to be executed."
-    )
-    async def notify_tool_execution_resumed_after_approval(self, approved: bool, tool_name: Optional[str]) -> None:
-        if approved and tool_name:
-            await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-        else:
-            logger.info(f"Agent '{self.context.agent_id}' tool execution denied for '{tool_name}'. Transitioning to allow LLM to process denial.")
-            await self.notify_tool_denied(tool_name)
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
-        target_phase=AgentOperationalPhase.TOOL_DENIED,
-        description="Occurs after a pending tool use has been denied by the user."
-    )
-    async def notify_tool_denied(self, tool_name: Optional[str]) -> None:
-        """Notifies that a tool execution has been denied."""
-        await self._transition_phase(
-            AgentOperationalPhase.TOOL_DENIED,
-            "notify_phase_tool_denied_started",
-            additional_data={"tool_name": tool_name, "denial_for_tool": tool_name}
-        )
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
-        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
-        description="Occurs when an agent with auto-approval executes a tool."
-    )
-    async def notify_tool_execution_started(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.EXECUTING_TOOL],
-        target_phase=AgentOperationalPhase.PROCESSING_TOOL_RESULT,
-        description="Fires after a tool has finished executing and the agent begins processing its result."
-    )
-    async def notify_processing_tool_result(self, tool_name: str) -> None:
-        await self._transition_phase(AgentOperationalPhase.PROCESSING_TOOL_RESULT, "notify_phase_processing_tool_result_started", additional_data={"tool_name": tool_name})
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.IDLE,
-        description="Occurs when an agent completes a processing cycle and is waiting for new input."
-    )
-    async def notify_processing_complete_and_idle(self) -> None:
-        if not self.context.current_phase.is_terminal() and self.context.current_phase != AgentOperationalPhase.IDLE:
-            await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
-        elif self.context.current_phase == AgentOperationalPhase.IDLE:
-            logger.debug(f"Agent '{self.context.agent_id}' processing complete, already IDLE.")
-        else:
-            logger.warning(f"Agent '{self.context.agent_id}' notify_processing_complete_and_idle called in unexpected phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.SHUTTING_DOWN
-        ],
-        target_phase=AgentOperationalPhase.ERROR,
-        description="A catch-all transition that can occur from any non-terminal state if an unrecoverable error happens."
-    )
-    async def notify_error_occurred(self, error_message: str, error_details: Optional[str] = None) -> None:
-        if self.context.current_phase != AgentOperationalPhase.ERROR:
-            data = {"error_message": error_message, "error_details": error_details}
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data=data)
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' already in ERROR phase when another error notified: {error_message}")
-
-    @phase_transition(
-        source_phases=[
-            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
-            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT
-        ],
-        target_phase=AgentOperationalPhase.SHUTTING_DOWN,
-        description="Fires when the agent begins its graceful shutdown sequence."
-    )
-    async def notify_shutdown_initiated(self) -> None:
-        if not self.context.current_phase.is_terminal():
-             await self._transition_phase(AgentOperationalPhase.SHUTTING_DOWN, "notify_phase_shutting_down_started")
-        else:
-            logger.debug(f"Agent '{self.context.agent_id}' shutdown initiated but already in a terminal phase: {self.context.current_phase.value}")
-
-    @phase_transition(
-        source_phases=[AgentOperationalPhase.SHUTTING_DOWN],
-        target_phase=AgentOperationalPhase.SHUTDOWN_COMPLETE,
-        description="The final transition when the agent has successfully shut down and released its resources."
-    )
-    async def notify_final_shutdown_complete(self) -> None:
-        final_phase = AgentOperationalPhase.ERROR if self.context.current_phase == AgentOperationalPhase.ERROR else AgentOperationalPhase.SHUTDOWN_COMPLETE
-        if final_phase == AgentOperationalPhase.ERROR:
-            await self._transition_phase(AgentOperationalPhase.ERROR, "notify_phase_error_entered", additional_data={"error_message": "Shutdown completed with agent in error state."})
-        else:
-            await self._transition_phase(AgentOperationalPhase.SHUTDOWN_COMPLETE, "notify_phase_shutdown_completed")

autobyteus/agent/context/phases.py

@@ -1,49 +0,0 @@
-# file: autobyteus/autobyteus/agent/context/phases.py
-from enum import Enum
-
-class AgentOperationalPhase(str, Enum):
-    """
-    Defines the fine-grained operational phases of an agent.
-    This is the single source of truth for an agent's current state of operation.
-    """
-    UNINITIALIZED = "uninitialized"            # Agent object created, but runtime not started or fully set up.
-    BOOTSTRAPPING = "bootstrapping"            # Agent is running its internal initialization/bootstrap sequence.
-    IDLE = "idle"                              # Fully initialized and ready for new input.
-    
-    PROCESSING_USER_INPUT = "processing_user_input"     # Actively processing a user message, typically preparing for an LLM call.
-    AWAITING_LLM_RESPONSE = "awaiting_llm_response"     # Sent a request to LLM, waiting for the full response or stream.
-    ANALYZING_LLM_RESPONSE = "analyzing_llm_response"   # Received LLM response, analyzing it for next actions (e.g., tool use, direct reply).
-    
-    AWAITING_TOOL_APPROVAL = "awaiting_tool_approval"   # Paused, needs external (user) approval for a tool invocation.
-    TOOL_DENIED = "tool_denied"                         # A proposed tool execution was denied by the user. Agent is processing the denial.
-    EXECUTING_TOOL = "executing_tool"                   # Tool has been approved (or auto-approved) and is currently running.
-    PROCESSING_TOOL_RESULT = "processing_tool_result"   # Received a tool's result, actively processing it (often leading to another LLM call).
-    
-    SHUTTING_DOWN = "shutting_down"               # Shutdown sequence has been initiated.
-    SHUTDOWN_COMPLETE = "shutdown_complete"       # Agent has fully stopped and released resources.
-    ERROR = "error"                               # An unrecoverable error has occurred. Agent might be non-operational.
-
-    def __str__(self) -> str:
-        return self.value
-
-    def is_initializing(self) -> bool:
-        """Checks if the agent is in any of the initializing phases."""
-        return self in [
-            AgentOperationalPhase.BOOTSTRAPPING,
-        ]
-
-    def is_processing(self) -> bool:
-        """Checks if the agent is in any active processing phase (post-initialization, pre-shutdown)."""
-        return self in [
-            AgentOperationalPhase.PROCESSING_USER_INPUT,
-            AgentOperationalPhase.AWAITING_LLM_RESPONSE,
-            AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
-            AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
-            AgentOperationalPhase.TOOL_DENIED,
-            AgentOperationalPhase.EXECUTING_TOOL,
-            AgentOperationalPhase.PROCESSING_TOOL_RESULT,
-        ]
-    
-    def is_terminal(self) -> bool:
-        """Checks if the phase is a terminal state (shutdown or error)."""
-        return self in [AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR]

autobyteus/agent/group/agent_group.py

@@ -1,164 +0,0 @@
-# file: autobyteus/autobyteus/agent/group/agent_group.py
-import asyncio
-import logging
-import uuid
-from typing import List, Dict, Optional, Any
-
-from autobyteus.agent.context.agent_config import AgentConfig
-from autobyteus.agent.factory import AgentFactory
-from autobyteus.agent.agent import Agent 
-from autobyteus.agent.group.agent_group_context import AgentGroupContext
-from autobyteus.agent.message.send_message_to import SendMessageTo
-from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-from autobyteus.agent.streaming.agent_event_stream import AgentEventStream
-from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class AgentGroup:
-    def __init__(self,
-                    agent_configs: List[AgentConfig],
-                    coordinator_config_name: str,
-                    group_id: Optional[str] = None): 
-        if not agent_configs or not all(isinstance(c, AgentConfig) for c in agent_configs):
-            raise TypeError("agent_configs must be a non-empty list of AgentConfig instances.")
-        if not coordinator_config_name or not isinstance(coordinator_config_name, str):
-            raise TypeError("coordinator_config_name must be a non-empty string.")
-        
-        self.group_id: str = group_id or f"group_{uuid.uuid4()}"
-        self.agent_factory = AgentFactory() # Get singleton instance
-        self._agent_configs_map: Dict[str, AgentConfig] = {
-            config.name: config for config in agent_configs
-        }
-        self.coordinator_config_name: str = coordinator_config_name
-        self.agents: List[Agent] = []
-        self.coordinator_agent: Optional[Agent] = None
-        self.group_context: Optional[AgentGroupContext] = None
-        self._is_initialized: bool = False
-        self._is_running: bool = False
-        
-        if self.coordinator_config_name not in self._agent_configs_map:
-            raise ValueError(f"Coordinator config name '{self.coordinator_config_name}' "
-                                f"not found in provided agent_configs. Available: {list(self._agent_configs_map.keys())}")
-        logger.info(f"AgentGroup '{self.group_id}' created with {len(agent_configs)} configurations. "
-                    f"Coordinator: '{self.coordinator_config_name}'.")
-        self._initialize_agents()
-
-    def _initialize_agents(self):
-        if self._is_initialized:
-            logger.warning(f"AgentGroup '{self.group_id}' agents already initialized. Skipping.")
-            return
-            
-        temp_agents_list: List[Agent] = []
-        temp_coordinator_agent: Optional[Agent] = None
-        for config_name, original_config in self._agent_configs_map.items():
-            
-            modified_tools = list(original_config.tools)
-            is_send_message_present = any(isinstance(tool, SendMessageTo) for tool in modified_tools)
-            if not is_send_message_present:
-                modified_tools.append(SendMessageTo())
-
-            # This logic correctly re-uses the user-provided LLM instance and other properties
-            # when creating the effective config for the agent factory.
-            effective_config = AgentConfig(
-                name=original_config.name,
-                role=original_config.role,
-                description=original_config.description,
-                llm_instance=original_config.llm_instance,
-                system_prompt=original_config.system_prompt,
-                tools=modified_tools, 
-                auto_execute_tools=original_config.auto_execute_tools,
-                use_xml_tool_format=original_config.use_xml_tool_format,
-                input_processors=original_config.input_processors,
-                llm_response_processors=original_config.llm_response_processors,
-                system_prompt_processors=original_config.system_prompt_processors,
-                workspace=original_config.workspace,
-                phase_hooks=original_config.phase_hooks,
-                initial_custom_data=original_config.initial_custom_data
-            )
-
-            try:
-                agent_instance = self.agent_factory.create_agent(config=effective_config)
-                temp_agents_list.append(agent_instance)
-                
-                if config_name == self.coordinator_config_name:
-                    temp_coordinator_agent = agent_instance
-                logger.debug(f"Agent '{agent_instance.agent_id}' (Role: {original_config.role}) created for group '{self.group_id}'.")
-            except Exception as e:
-                logger.error(f"Failed to create agent for config '{config_name}' for group '{self.group_id}': {e}", exc_info=True)
-                raise RuntimeError(f"Failed to initialize agent for config '{config_name}' in group '{self.group_id}'.") from e
-                
-        if not temp_coordinator_agent:
-            raise RuntimeError(f"Coordinator agent '{self.coordinator_config_name}' could not be instantiated.")
-        
-        self.agents = temp_agents_list
-        self.coordinator_agent = temp_coordinator_agent
-        self.group_context = AgentGroupContext(group_id=self.group_id, agents=self.agents, coordinator_agent_id=self.coordinator_agent.agent_id)
-        for agent in self.agents:
-            agent.context.custom_data['agent_group_context'] = self.group_context
-        self._is_initialized = True
-        logger.info(f"AgentGroup '{self.group_id}' all {len(self.agents)} agents initialized successfully.")
-
-    async def start(self):
-        if not self._is_initialized: raise RuntimeError(f"AgentGroup '{self.group_id}' must be initialized before starting.")
-        if self._is_running: logger.warning(f"AgentGroup '{self.group_id}' is already running."); return
-        logger.info(f"Starting all agents in AgentGroup '{self.group_id}'..."); self._is_running = True 
-        try:
-            for agent in self.agents:
-                if not agent.is_running:
-                    agent.start()
-            # Give loops a chance to start
-            await asyncio.sleep(0.01)
-            logger.info(f"All agents in AgentGroup '{self.group_id}' have been requested to start.")
-        except Exception as e:
-            self._is_running = False; logger.error(f"Error starting agents in AgentGroup '{self.group_id}': {e}", exc_info=True)
-            await self.stop(timeout=2.0); raise
-
-    async def stop(self, timeout: float = 10.0):
-        if not self._is_running and not any(a.is_running for a in self.agents): 
-            logger.info(f"AgentGroup '{self.group_id}' is already stopped or was never started."); self._is_running = False; return
-        logger.info(f"Stopping all agents in AgentGroup '{self.group_id}' with timeout {timeout}s...")
-        stop_tasks = [agent.stop(timeout=timeout) for agent in self.agents]
-        results = await asyncio.gather(*stop_tasks, return_exceptions=True)
-        for agent, result in zip(self.agents, results):
-            if isinstance(result, Exception): logger.error(f"Error stopping agent '{agent.agent_id}': {result}", exc_info=result)
-        self._is_running = False; logger.info(f"All agents in AgentGroup '{self.group_id}' have been requested to stop.")
-
-    async def process_task_for_coordinator(self, initial_input_content: str, user_id: Optional[str] = None) -> Any:
-        if not self.coordinator_agent: raise RuntimeError(f"Coordinator agent not set in group '{self.group_id}'.")
-        await self.start() 
-        final_response_aggregator = ""
-        output_stream_listener_task = None
-        streamer = None
-        try:
-            streamer = AgentEventStream(self.coordinator_agent) 
-            async def listen_for_final_output():
-                nonlocal final_response_aggregator
-                try:
-                    async for complete_response_data in streamer.stream_assistant_final_response():
-                        final_response_aggregator += complete_response_data.content
-                except Exception as e_stream:
-                    logger.error(f"Error streaming final output from coordinator: {e_stream}", exc_info=True)
-            output_stream_listener_task = asyncio.create_task(listen_for_final_output())
-            input_message = AgentInputUserMessage(content=initial_input_content, metadata={"user_id": user_id} if user_id else {})
-            await self.coordinator_agent.post_user_message(input_message)
-            
-            # Wait for the listener to finish, which happens after the agent is done and the stream closes.
-            if output_stream_listener_task: 
-                await output_stream_listener_task
-            
-            return final_response_aggregator
-        finally:
-            if output_stream_listener_task and not output_stream_listener_task.done():
-                output_stream_listener_task.cancel()
-            if streamer: await streamer.close()
-
-    def get_agent_by_id(self, agent_id: str) -> Optional[Agent]:
-        return next((agent for agent in self.agents if agent.agent_id == agent_id), None)
-
-    def get_agents_by_role(self, role_name: str) -> List[Agent]:
-        return [agent for agent in self.agents if agent.context.config.role == role_name]
-
-    @property
-    def is_running(self) -> bool:
-        return self._is_running and any(a.is_running for a in self.agents)

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