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

autobyteus/agent/workspace/base_workspace.py

@@ -1,5 +1,6 @@
 # file: autobyteus/autobyteus/agent/workspace/base_workspace.py
 import logging
+import uuid
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Dict, TYPE_CHECKING
 from autobyteus.tools.parameter_schema import ParameterSchema
@@ -29,7 +30,8 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         """
         self._config: WorkspaceConfig = config or WorkspaceConfig()
         self.context: Optional['AgentContext'] = None
-        logger.debug(f"{self.__class__.__name__} instance initialized. Context pending injection.")
+        self.workspace_id: str = str(uuid.uuid4())
+        logger.debug(f"{self.__class__.__name__} instance initialized with ID {self.workspace_id}. Context pending injection.")
 
     def set_context(self, context: 'AgentContext'):
         """
@@ -53,6 +55,19 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         """Configuration for the workspace. Implementations can use this as needed."""
         return self._config
 
+    @abstractmethod
+    def get_base_path(self) -> str:
+        """Returns the base path for the workspace, which can be used to resolve relative paths."""
+        pass
+    
+    def get_name(self) -> str:
+        """
+        Returns a user-friendly name for this workspace instance.
+        By default, it returns the unique workspace ID.
+        Subclasses can override this to provide a more descriptive name (e.g., a directory name).
+        """
+        return self.workspace_id
+
     # --- Methods for self-description ---
 
     @classmethod
@@ -74,4 +89,4 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         pass
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} agent_id='{self.agent_id or 'N/A'}>"
+        return f"<{self.__class__.__name__} workspace_id='{self.workspace_id}' agent_id='{self.agent_id or 'N/A'}>"

autobyteus/agent_team/__init__.py

@@ -0,0 +1 @@
+# file: autobyteus/autobyteus/agent_team/__init__.py

autobyteus/agent_team/agent_team.py

@@ -0,0 +1,93 @@
+# file: autobyteus/autobyteus/agent_team/agent_team.py
+import logging
+from typing import Optional
+
+from autobyteus.agent_team.runtime.agent_team_runtime import AgentTeamRuntime
+from autobyteus.agent_team.events.agent_team_events import ProcessUserMessageEvent, ToolApprovalTeamEvent
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+
+logger = logging.getLogger(__name__)
+
+class AgentTeam:
+    """
+    User-facing facade for interacting with a managed agent team.
+    This class is a lightweight wrapper around an AgentTeamRuntime instance
+    and is typically created by an AgentTeamFactory.
+    """
+    def __init__(self, runtime: AgentTeamRuntime):
+        """
+        Initializes the AgentTeam facade.
+
+        Args:
+            runtime: The pre-configured and ready-to-use runtime for the agent team.
+        """
+        if not isinstance(runtime, AgentTeamRuntime):
+            raise TypeError(f"AgentTeam requires an AgentTeamRuntime instance, got {type(runtime).__name__}")
+        
+        self._runtime = runtime
+        self.team_id: str = self._runtime.context.team_id
+        logger.info(f"AgentTeam facade created for team ID '{self.team_id}'.")
+
+    @property
+    def name(self) -> str:
+        return self._runtime.context.config.name
+
+    @property
+    def role(self) -> Optional[str]:
+        """The role of the team, for when it's used as a sub-team."""
+        return self._runtime.context.config.role
+
+    async def post_message(self, message: AgentInputUserMessage, target_agent_name: Optional[str] = None) -> None:
+        """
+        Submits a message to the agent team, routing it to a specific node (agent or sub-team).
+        If `target_agent_name` is not provided, the message is sent to the team's coordinator.
+        """
+        final_target_name = target_agent_name or self._runtime.context.config.coordinator_node.name
+        logger.info(f"Agent Team '{self.team_id}': post_message called. Target: '{final_target_name}'.")
+
+        if not self._runtime.is_running:
+            self.start()
+        
+        event = ProcessUserMessageEvent(
+            user_message=message,
+            target_agent_name=final_target_name
+        )
+        await self._runtime.submit_event(event)
+
+    async def post_tool_execution_approval(
+        self,
+        agent_name: str,
+        tool_invocation_id: str,
+        is_approved: bool,
+        reason: Optional[str] = None
+    ):
+        """Submits a tool execution approval/denial to a specific agent in the team."""
+        logger.info(f"Agent Team '{self.team_id}': post_tool_execution_approval called for agent '{agent_name}'. Approved: {is_approved}.")
+        if not self._runtime.is_running:
+            logger.warning(f"Agent Team '{self.team_id}' is not running. Cannot post approval.")
+            return
+
+        event = ToolApprovalTeamEvent(
+            agent_name=agent_name,
+            tool_invocation_id=tool_invocation_id,
+            is_approved=is_approved,
+            reason=reason,
+        )
+        await self._runtime.submit_event(event)
+
+    def start(self) -> None:
+        """Starts the agent team's background worker thread."""
+        self._runtime.start()
+
+    async def stop(self, timeout: float = 10.0) -> None:
+        """Stops the agent team and all its agents."""
+        await self._runtime.stop(timeout)
+
+    @property
+    def is_running(self) -> bool:
+        """Checks if the agent team's worker is running."""
+        return self._runtime.is_running
+        
+    def get_current_phase(self) -> AgentTeamOperationalPhase: 
+        return self._runtime.context.state.current_phase

autobyteus/agent_team/agent_team_builder.py

@@ -0,0 +1,184 @@
+# file: autobyteus/autobyteus/agent_team/agent_team_builder.py
+import logging
+from typing import List, Optional, Dict, Union, Set
+
+from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent_team.context.agent_team_config import AgentTeamConfig
+from autobyteus.agent_team.context.team_node_config import TeamNodeConfig
+from autobyteus.agent.context.agent_config import AgentConfig
+from autobyteus.agent_team.factory.agent_team_factory import AgentTeamFactory
+from autobyteus.agent_team.task_notification.task_notification_mode import TaskNotificationMode
+
+logger = logging.getLogger(__name__)
+
+# Define a type hint for the possible definition types for clarity
+NodeDefinition = Union[AgentConfig, AgentTeamConfig]
+
+class AgentTeamBuilder:
+    """
+    A fluent API for constructing and configuring an AgentTeam.
+    
+    This builder simplifies creating an agent team by abstracting away the manual
+    creation of config objects and providing an intuitive way to define the
+    agent and sub-team graph. It enforces that all nodes within the team have
+    a unique name.
+    """
+    def __init__(self, name: str, description: str, role: Optional[str] = None):
+        """
+        Initializes the AgentTeamBuilder.
+
+        Args:
+            name: A unique name for the agent team.
+            description: A high-level description of the team's goal.
+            role: An optional role description for when this team is used
+                  as a sub-team within a parent.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Agent team name must be a non-empty string.")
+        if not description or not isinstance(description, str):
+            raise ValueError("Agent team description must be a non-empty string.")
+
+        self._name = name
+        self._description = description
+        self._role = role
+        self._nodes: Dict[NodeDefinition, List[NodeDefinition]] = {}
+        self._coordinator_config: Optional[AgentConfig] = None
+        self._added_node_names: Set[str] = set()
+        self._task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+        logger.info(f"AgentTeamBuilder initialized for team: '{self._name}'.")
+
+    def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
+        """
+        Adds a regular agent node to the agent team.
+
+        Args:
+            agent_config: The configuration for the agent at this node.
+            dependencies: A list of AgentConfig or AgentTeamConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(agent_config, dependencies)
+        return self
+
+    def add_sub_team_node(self, team_config: AgentTeamConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
+        """
+        Adds a sub-team node to the agent team.
+
+        Args:
+            team_config: The configuration for the sub-team.
+            dependencies: A list of AgentConfig or AgentTeamConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(team_config, dependencies)
+        return self
+
+    def _add_node_internal(self, node_definition: NodeDefinition, dependencies: Optional[List[NodeDefinition]]):
+        """Internal helper to add a node of any type."""
+        if not isinstance(node_definition, (AgentConfig, AgentTeamConfig)):
+            raise TypeError("node_definition must be an instance of AgentConfig or AgentTeamConfig.")
+        
+        node_name = node_definition.name
+        if node_name in self._added_node_names:
+            # Enforce unique names. This is the new, simpler validation.
+            raise ValueError(f"Duplicate node name '{node_name}' detected. All nodes in a team must have a unique name.")
+
+        if node_definition in self._nodes or node_definition == self._coordinator_config:
+            raise ValueError(f"The exact same node definition object for '{node_name}' has already been added to the team.")
+
+        if dependencies:
+            for dep_config in dependencies:
+                if dep_config not in self._nodes and dep_config != self._coordinator_config:
+                    raise ValueError(f"Dependency node '{dep_config.name}' must be added to the builder before being used as a dependency.")
+
+        self._nodes[node_definition] = dependencies or []
+        self._added_node_names.add(node_name)
+        
+        node_type = "Sub-Team" if isinstance(node_definition, AgentTeamConfig) else "Agent"
+        logger.debug(f"Added {node_type} node '{node_name}' to builder with {len(dependencies or [])} dependencies.")
+
+    def set_coordinator(self, agent_config: AgentConfig) -> 'AgentTeamBuilder':
+        """
+        Sets the coordinator agent for the team. A coordinator must be an agent.
+
+        Args:
+            agent_config: The configuration for the coordinator agent.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if self._coordinator_config is not None:
+            raise ValueError("A coordinator has already been set for this team.")
+            
+        if not isinstance(agent_config, AgentConfig):
+            raise TypeError("Coordinator must be an instance of AgentConfig.")
+            
+        node_name = agent_config.name
+        if node_name in self._added_node_names:
+            raise ValueError(f"Duplicate node name '{node_name}' detected. The coordinator's name must also be unique within the team.")
+
+        self._coordinator_config = agent_config
+        self._added_node_names.add(node_name)
+        logger.debug(f"Set coordinator for team to '{agent_config.name}'.")
+        return self
+
+    def set_task_notification_mode(self, mode: TaskNotificationMode) -> 'AgentTeamBuilder':
+        """
+        Sets the task notification mode for the team.
+
+        Args:
+            mode: The desired TaskNotificationMode (AGENT_MANUAL_NOTIFICATION or SYSTEM_EVENT_DRIVEN).
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if not isinstance(mode, TaskNotificationMode):
+            raise TypeError("mode must be an instance of TaskNotificationMode.")
+        self._task_notification_mode = mode
+        logger.debug(f"Task notification mode set to '{mode.value}'.")
+        return self
+
+    def build(self) -> AgentTeam:
+        """
+        Constructs and returns the final AgentTeam instance using the
+        singleton AgentTeamFactory.
+        """
+        logger.info("Building AgentTeam from builder...")
+        if self._coordinator_config is None:
+            raise ValueError("Cannot build team: A coordinator must be set.")
+
+        node_map: Dict[NodeDefinition, TeamNodeConfig] = {}
+        # Ensure the coordinator config is also in the set of definitions to process
+        all_definitions = list(self._nodes.keys())
+        if self._coordinator_config not in all_definitions:
+             all_definitions.append(self._coordinator_config)
+        
+        for definition in all_definitions:
+            node_map[definition] = TeamNodeConfig(node_definition=definition)
+        
+        for node_def, dep_defs in self._nodes.items():
+            if node_def in node_map and dep_defs:
+                current_node = node_map[node_def]
+                dependency_nodes = [node_map[dep_def] for dep_def in dep_defs]
+                current_node.dependencies = tuple(dependency_nodes)
+
+        final_nodes = list(node_map.values())
+        coordinator_node_instance = node_map[self._coordinator_config]
+
+        team_config = AgentTeamConfig(
+            name=self._name,
+            description=self._description,
+            role=self._role,
+            nodes=tuple(final_nodes),
+            coordinator_node=coordinator_node_instance,
+            task_notification_mode=self._task_notification_mode
+        )
+        
+        logger.info(f"AgentTeamConfig created successfully. Name: '{team_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")
+
+        factory = AgentTeamFactory()
+        return factory.create_team(config=team_config)

autobyteus/agent_team/base_agent_team.py

@@ -0,0 +1,86 @@
+# file: autobyteus/autobyteus/agent_team/base_agent_team.py
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, Any, TYPE_CHECKING
+
+# These are forward declarations that might be used by subclasses.
+if TYPE_CHECKING:
+    from autobyteus.agent_team.agent_team import AgentTeam
+
+logger = logging.getLogger(__name__)
+
+class BaseAgentTeam(ABC):
+    """
+    Optional abstract base class for creating domain-specific, type-safe
+    APIs for agent teams.
+
+    Users can subclass BaseAgentTeam to create a more structured and
+    specific interface for their multi-agent tasks, rather than using the
+    generic `AgentTeam.process(**kwargs)` method directly.
+
+    Subclasses would typically encapsulate an `AgentTeam` instance and define
+    methods that map domain-specific inputs to the underlying team's execution.
+    """
+
+    def __init__(self,
+                 name: str,
+                 wrapped_team_instance: Optional['AgentTeam'] = None):
+        """
+        Initializes the BaseAgentTeam.
+
+        Args:
+            name: A descriptive name for this specific team implementation.
+            wrapped_team_instance: Optional. An instance of AgentTeam that this class
+                                   will wrap and delegate to. If not provided, the subclass
+                                   is responsible for initializing its own team instance.
+        """
+        self.name: str = name
+        self._wrapped_team: Optional[Any] = wrapped_team_instance
+        
+        if self._wrapped_team:
+            logger.info(f"BaseAgentTeam '{self.name}' initialized, wrapping an instance of "
+                        f"'{self._wrapped_team.__class__.__name__}'.")
+        else:
+            logger.info(f"BaseAgentTeam '{self.name}' initialized without a pre-wrapped instance. "
+                        "Subclass should handle team setup.")
+
+    @property
+    def wrapped_team(self) -> Optional[Any]:
+        """Provides access to the wrapped AgentTeam instance."""
+        return self._wrapped_team
+
+    @abstractmethod
+    async def start(self) -> None:
+        """
+        Starts the team. Subclasses should implement this to delegate
+        to the start method of their wrapped AgentTeam.
+        """
+        pass
+
+    @abstractmethod
+    async def stop(self, timeout: float = 10.0) -> None:
+        """
+        Stops the team. Subclasses should implement this to delegate
+        to the stop method of their wrapped AgentTeam.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def is_running(self) -> bool:
+        """
+        Checks if the team is currently running. Subclasses should implement
+        this to delegate to the is_running property of their wrapped instance.
+        """
+        pass
+    
+    def __repr__(self) -> str:
+        running_status = "N/A (not implemented by subclass)"
+        try:
+            running_status = str(self.is_running)
+        except NotImplementedError:
+            pass
+            
+        return (f"<{self.__class__.__name__} name='{self.name}', "
+                f"wraps='{self._wrapped_team.__class__.__name__ if self._wrapped_team else 'NoneInternal'}', "
+                f"is_running={running_status}>")

autobyteus/agent_team/bootstrap_steps/__init__.py

@@ -0,0 +1,24 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/__init__.py
+"""
+Defines individual, self-contained steps for the agent team bootstrapping process.
+"""
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent_team.bootstrap_steps.agent_team_runtime_queue_initialization_step import AgentTeamRuntimeQueueInitializationStep
+from autobyteus.agent_team.bootstrap_steps.team_context_initialization_step import TeamContextInitializationStep
+from autobyteus.agent_team.bootstrap_steps.task_notifier_initialization_step import TaskNotifierInitializationStep
+from autobyteus.agent_team.bootstrap_steps.coordinator_prompt_preparation_step import CoordinatorPromptPreparationStep
+from autobyteus.agent_team.bootstrap_steps.agent_configuration_preparation_step import AgentConfigurationPreparationStep
+from autobyteus.agent_team.bootstrap_steps.coordinator_initialization_step import CoordinatorInitializationStep
+from autobyteus.agent_team.bootstrap_steps.agent_team_bootstrapper import AgentTeamBootstrapper
+
+__all__ = [
+    "BaseAgentTeamBootstrapStep",
+    "AgentTeamRuntimeQueueInitializationStep",
+    "TeamContextInitializationStep",
+    "TaskNotifierInitializationStep",
+    "CoordinatorPromptPreparationStep",
+    "AgentConfigurationPreparationStep",
+    "CoordinatorInitializationStep",
+    "AgentTeamBootstrapper",
+]

autobyteus/agent_team/bootstrap_steps/agent_configuration_preparation_step.py

@@ -0,0 +1,73 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_configuration_preparation_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent.context import AgentConfig
+from autobyteus.agent.message.send_message_to import SendMessageTo
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
+    """
+    Bootstrap step to prepare the final, immutable configuration for every
+    agent in the team. It injects team-specific context and applies the final
+    coordinator prompt. It no longer injects tools.
+    """
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing AgentConfigurationPreparationStep to prepare all agent configurations.")
+        
+        team_manager = context.team_manager
+        if not team_manager:
+            logger.error(f"Team '{team_id}': TeamManager not found in context during agent config preparation.")
+            return False
+
+        try:
+            coordinator_node_config = context.config.coordinator_node
+            
+            for node_config_wrapper in context.config.nodes:
+                # This step only configures direct agent members, not sub-teams.
+                if node_config_wrapper.is_sub_team:
+                    continue
+
+                unique_name = node_config_wrapper.name
+                node_definition = node_config_wrapper.node_definition
+
+                if not isinstance(node_definition, AgentConfig):
+                    logger.warning(f"Team '{team_id}': Node '{unique_name}' has an unexpected definition type and will be skipped: {type(node_definition)}")
+                    continue
+                
+                final_config = node_definition.copy()
+
+                # --- Shared Context Injection ---
+                # The shared context is injected into the initial_custom_data dictionary,
+                # which is then used by the AgentFactory to create the AgentRuntimeState.
+                if final_config.initial_custom_data is None:
+                    final_config.initial_custom_data = {}
+                final_config.initial_custom_data["team_context"] = context
+                logger.debug(f"Team '{team_id}': Injected shared team_context into initial_custom_data for agent '{unique_name}'.")
+
+                # --- Tool Injection Logic Removed ---
+                # The user is now fully responsible for defining all tools an agent needs
+                # in its AgentConfig. The framework no longer implicitly injects SendMessageTo.
+                
+                # If this is the coordinator, apply the prompt that was prepared in the previous step.
+                if node_config_wrapper == coordinator_node_config:
+                    coordinator_prompt = context.state.prepared_coordinator_prompt
+                    if coordinator_prompt:
+                        final_config.system_prompt = coordinator_prompt
+                        logger.info(f"Team '{team_id}': Applied dynamic prompt to coordinator '{unique_name}'.")
+
+                # Store the final, ready-to-use config in the team's state
+                context.state.final_agent_configs[unique_name] = final_config
+                logger.info(f"Team '{team_id}': Prepared final config for agent '{unique_name}' with user-defined tools: {[t.get_name() for t in final_config.tools]}")
+            
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Failed during agent configuration preparation: {e}", exc_info=True)
+            return False

autobyteus/agent_team/bootstrap_steps/agent_team_bootstrapper.py

@@ -0,0 +1,54 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_team_bootstrapper.py
+import logging
+from typing import TYPE_CHECKING, List, Optional
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent_team.bootstrap_steps.agent_team_runtime_queue_initialization_step import AgentTeamRuntimeQueueInitializationStep
+from autobyteus.agent_team.bootstrap_steps.team_context_initialization_step import TeamContextInitializationStep
+from autobyteus.agent_team.bootstrap_steps.task_notifier_initialization_step import TaskNotifierInitializationStep
+from autobyteus.agent_team.bootstrap_steps.coordinator_prompt_preparation_step import CoordinatorPromptPreparationStep
+from autobyteus.agent_team.bootstrap_steps.agent_configuration_preparation_step import AgentConfigurationPreparationStep
+from autobyteus.agent_team.bootstrap_steps.coordinator_initialization_step import CoordinatorInitializationStep
+from autobyteus.agent_team.events.agent_team_events import AgentTeamReadyEvent
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentTeamBootstrapper:
+    """Orchestrates the agent team's bootstrapping process."""
+    def __init__(self, steps: Optional[List[BaseAgentTeamBootstrapStep]] = None):
+        self.bootstrap_steps = steps or [
+            AgentTeamRuntimeQueueInitializationStep(),
+            TeamContextInitializationStep(),
+            TaskNotifierInitializationStep(),
+            CoordinatorPromptPreparationStep(),
+            AgentConfigurationPreparationStep(),
+            CoordinatorInitializationStep(),
+        ]
+
+    async def run(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        await phase_manager.notify_bootstrapping_started()
+        logger.info(f"Team '{team_id}': Bootstrapper starting.")
+
+        for step in self.bootstrap_steps:
+            step_name = step.__class__.__name__
+            logger.debug(f"Team '{team_id}': Executing bootstrap step: {step_name}")
+            if not await step.execute(context, phase_manager):
+                error_message = f"Bootstrap step {step_name} failed."
+                logger.error(f"Team '{team_id}': {error_message}")
+                await phase_manager.notify_error_occurred(error_message, f"Failed during bootstrap step '{step_name}'.")
+                return False
+        
+        logger.info(f"Team '{team_id}': All bootstrap steps completed successfully.")
+        if context.state.input_event_queues:
+            await context.state.input_event_queues.enqueue_internal_system_event(AgentTeamReadyEvent())
+        else:
+            logger.critical(f"Team '{team_id}': Bootstrap succeeded but queues not available.")
+            await phase_manager.notify_error_occurred("Queues unavailable after bootstrap.", "")
+            return False
+            
+        return True

autobyteus/agent_team/bootstrap_steps/agent_team_runtime_queue_initialization_step.py

@@ -0,0 +1,25 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/agent_team_runtime_queue_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+from autobyteus.agent_team.events.agent_team_input_event_queue_manager import AgentTeamInputEventQueueManager
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentTeamRuntimeQueueInitializationStep(BaseAgentTeamBootstrapStep):
+    """Bootstrap step for initializing the agent team's runtime event queues."""
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing AgentTeamRuntimeQueueInitializationStep.")
+        try:
+            context.state.input_event_queues = AgentTeamInputEventQueueManager()
+            logger.info(f"Team '{team_id}': AgentTeamInputEventQueueManager initialized.")
+            return True
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Critical failure during queue initialization: {e}", exc_info=True)
+            return False

autobyteus/agent_team/bootstrap_steps/base_agent_team_bootstrap_step.py

@@ -0,0 +1,23 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/base_agent_team_bootstrap_step.py
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class BaseAgentTeamBootstrapStep(ABC):
+    """Abstract base class for individual steps in the agent team bootstrapping process."""
+
+    @abstractmethod
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        """
+        Executes the bootstrap step.
+
+        Returns:
+            True if the step completed successfully, False otherwise.
+        """
+        raise NotImplementedError("Subclasses must implement the 'execute' method.")

autobyteus/agent_team/bootstrap_steps/coordinator_initialization_step.py

@@ -0,0 +1,41 @@
+# file: autobyteus/autobyteus/agent_team/bootstrap_steps/coordinator_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.bootstrap_steps.base_agent_team_bootstrap_step import BaseAgentTeamBootstrapStep
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class CoordinatorInitializationStep(BaseAgentTeamBootstrapStep):
+    """
+    Bootstrap step that eagerly instantiates and starts the coordinator agent
+    using the TeamManager. This ensures the coordinator is ready before the
+    agent team becomes idle.
+    """
+    async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
+        team_id = context.team_id
+        logger.info(f"Team '{team_id}': Executing CoordinatorInitializationStep.")
+        
+        try:
+            team_manager = context.team_manager
+            if not team_manager:
+                raise RuntimeError("TeamManager not found in team context. It should be created by the factory.")
+
+            coordinator_name = context.config.coordinator_node.name
+
+            # This call now ensures the coordinator agent is fully created and ready.
+            coordinator = await team_manager.ensure_coordinator_is_ready(coordinator_name)
+            
+            if not coordinator:
+                raise RuntimeError(f"TeamManager failed to return a ready coordinator agent for '{coordinator_name}'.")
+
+            logger.info(f"Team '{team_id}': Coordinator '{coordinator_name}' initialized and started via TeamManager.")
+            return True
+        
+        except Exception as e:
+            logger.error(f"Team '{team_id}': Failed to initialize coordinator agent: {e}", exc_info=True)
+            return False