autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/agent_team/events/event_store.py

@@ -0,0 +1,57 @@
+# file: autobyteus/autobyteus/agent_team/events/event_store.py
+from __future__ import annotations
+
+import logging
+import time
+import uuid
+from dataclasses import dataclass
+from typing import List, Optional
+
+from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class EventEnvelope:
+    event_id: str
+    event_type: str
+    timestamp: float
+    team_id: str
+    event: BaseAgentTeamEvent
+    correlation_id: Optional[str] = None
+    caused_by_event_id: Optional[str] = None
+    sequence: int = 0
+
+
+class AgentTeamEventStore:
+    """
+    Simple in-memory event store for agent team events.
+    """
+    def __init__(self, team_id: str):
+        self._team_id = team_id
+        self._events: List[EventEnvelope] = []
+        self._sequence: int = 0
+        logger.debug(f"AgentTeamEventStore initialized for team_id '{team_id}'.")
+
+    def append(self,
+               event: BaseAgentTeamEvent,
+               correlation_id: Optional[str] = None,
+               caused_by_event_id: Optional[str] = None) -> EventEnvelope:
+        envelope = EventEnvelope(
+            event_id=str(uuid.uuid4()),
+            event_type=type(event).__name__,
+            timestamp=time.time(),
+            team_id=self._team_id,
+            event=event,
+            correlation_id=correlation_id,
+            caused_by_event_id=caused_by_event_id,
+            sequence=self._sequence,
+        )
+        self._sequence += 1
+        self._events.append(envelope)
+        logger.debug(f"Appended event '{envelope.event_type}' to store for team '{self._team_id}'.")
+        return envelope
+
+    def all_events(self) -> List[EventEnvelope]:
+        return list(self._events)

autobyteus/agent_team/factory/agent_team_factory.py

@@ -17,7 +17,11 @@ from autobyteus.agent_team.handlers.inter_agent_message_request_event_handler im
 from autobyteus.agent_team.handlers.tool_approval_team_event_handler import ToolApprovalTeamEventHandler
 from autobyteus.agent_team.events.agent_team_events import (
     ProcessUserMessageEvent,
+    AgentTeamBootstrapStartedEvent,
     AgentTeamReadyEvent,
+    AgentTeamIdleEvent,
+    AgentTeamShutdownRequestedEvent,
+    AgentTeamStoppedEvent,
     AgentTeamErrorEvent,
     InterAgentMessageRequestEvent,
     ToolApprovalTeamEvent
@@ -41,7 +45,11 @@ class AgentTeamFactory(metaclass=SingletonMeta):
         registry.register(InterAgentMessageRequestEvent, InterAgentMessageRequestEventHandler())
         registry.register(ToolApprovalTeamEvent, ToolApprovalTeamEventHandler())
         lifecycle_handler = LifecycleAgentTeamEventHandler()
+        registry.register(AgentTeamBootstrapStartedEvent, lifecycle_handler)
         registry.register(AgentTeamReadyEvent, lifecycle_handler)
+        registry.register(AgentTeamIdleEvent, lifecycle_handler)
+        registry.register(AgentTeamShutdownRequestedEvent, lifecycle_handler)
+        registry.register(AgentTeamStoppedEvent, lifecycle_handler)
         registry.register(AgentTeamErrorEvent, lifecycle_handler)
         return registry
 

autobyteus/agent_team/handlers/inter_agent_message_request_event_handler.py

@@ -3,7 +3,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.handlers.base_agent_team_event_handler import BaseAgentTeamEventHandler
-from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent
+from autobyteus.agent_team.events.agent_team_events import InterAgentMessageRequestEvent, AgentTeamErrorEvent
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent_team.agent_team import AgentTeam
@@ -24,7 +24,12 @@ class InterAgentMessageRequestEventHandler(BaseAgentTeamEventHandler):
         team_manager = context.team_manager
         
         if not team_manager:
-            logger.error(f"Team '{team_id}': TeamManager not found. Cannot route message from '{event.sender_agent_id}' to '{event.recipient_name}'.")
+            msg = f"Team '{team_id}': TeamManager not found. Cannot route message from '{event.sender_agent_id}' to '{event.recipient_name}'."
+            logger.error(msg)
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=msg, exception_details="TeamManager is not initialized.")
+                )
             return
 
         try:
@@ -32,6 +37,13 @@ class InterAgentMessageRequestEventHandler(BaseAgentTeamEventHandler):
         except Exception as e:
             msg = f"Recipient node '{event.recipient_name}' not found or failed to start for message from '{event.sender_agent_id}'. Error: {e}"
             logger.error(f"Team '{team_id}': {msg}", exc_info=True)
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(
+                        error_message=f"Team '{team_id}': {msg}",
+                        exception_details=f"Node '{event.recipient_name}' not found or failed to start."
+                    )
+                )
             return
 
         try:
@@ -59,3 +71,7 @@ class InterAgentMessageRequestEventHandler(BaseAgentTeamEventHandler):
         except Exception as e:
             msg = f"Error posting message to node '{event.recipient_name}': {e}"
             logger.error(f"Team '{team_id}': {msg}", exc_info=True)
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=f"Team '{team_id}': {msg}", exception_details="Message delivery failed.")
+                )

autobyteus/agent_team/handlers/lifecycle_agent_team_event_handler.py

@@ -3,7 +3,15 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.handlers.base_agent_team_event_handler import BaseAgentTeamEventHandler
-from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent, AgentTeamReadyEvent, AgentTeamErrorEvent
+from autobyteus.agent_team.events.agent_team_events import (
+    BaseAgentTeamEvent,
+    AgentTeamBootstrapStartedEvent,
+    AgentTeamReadyEvent,
+    AgentTeamIdleEvent,
+    AgentTeamShutdownRequestedEvent,
+    AgentTeamStoppedEvent,
+    AgentTeamErrorEvent,
+)
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
@@ -14,14 +22,22 @@ class LifecycleAgentTeamEventHandler(BaseAgentTeamEventHandler):
     """Logs various lifecycle events for an agent team."""
     async def handle(self, event: BaseAgentTeamEvent, context: 'AgentTeamContext') -> None:
         team_id = context.team_id
-        current_phase = context.state.current_phase.value
+        current_status = context.state.current_status.value
 
-        if isinstance(event, AgentTeamReadyEvent):
-            logger.info(f"Team '{team_id}' Logged AgentTeamReadyEvent. Current phase: {current_phase}")
+        if isinstance(event, AgentTeamBootstrapStartedEvent):
+            logger.info(f"Team '{team_id}' Logged AgentTeamBootstrapStartedEvent. Current status: {current_status}")
+        elif isinstance(event, AgentTeamReadyEvent):
+            logger.info(f"Team '{team_id}' Logged AgentTeamReadyEvent. Current status: {current_status}")
+        elif isinstance(event, AgentTeamIdleEvent):
+            logger.info(f"Team '{team_id}' Logged AgentTeamIdleEvent. Current status: {current_status}")
+        elif isinstance(event, AgentTeamShutdownRequestedEvent):
+            logger.info(f"Team '{team_id}' Logged AgentTeamShutdownRequestedEvent. Current status: {current_status}")
+        elif isinstance(event, AgentTeamStoppedEvent):
+            logger.info(f"Team '{team_id}' Logged AgentTeamStoppedEvent. Current status: {current_status}")
         elif isinstance(event, AgentTeamErrorEvent):
             logger.error(
                 f"Team '{team_id}' Logged AgentTeamErrorEvent: {event.error_message}. "
-                f"Details: {event.exception_details}. Current phase: {current_phase}"
+                f"Details: {event.exception_details}. Current status: {current_status}"
             )
         else:
             logger.warning(f"LifecycleAgentTeamEventHandler received unhandled event type: {type(event).__name__}")

autobyteus/agent_team/handlers/process_user_message_event_handler.py

@@ -1,8 +1,9 @@
 # file: autobyteus/autobyteus/agent_team/handlers/process_user_message_event_handler.py
 import logging
 from typing import TYPE_CHECKING
+
 from autobyteus.agent_team.handlers.base_agent_team_event_handler import BaseAgentTeamEventHandler
-from autobyteus.agent_team.events.agent_team_events import ProcessUserMessageEvent
+from autobyteus.agent_team.events.agent_team_events import ProcessUserMessageEvent, AgentTeamErrorEvent
 from autobyteus.agent.agent import Agent
 from autobyteus.agent_team.agent_team import AgentTeam
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
@@ -15,13 +16,14 @@ logger = logging.getLogger(__name__)
 class ProcessUserMessageEventHandler(BaseAgentTeamEventHandler):
     """Handles user messages by routing them to the specified target agent or sub-team."""
     async def handle(self, event: ProcessUserMessageEvent, context: 'AgentTeamContext') -> None:
-        await context.phase_manager.notify_processing_started()
-        
         team_manager = context.team_manager
         if not team_manager:
             msg = f"Team '{context.team_id}': TeamManager not found. Cannot route message."
             logger.error(msg)
-            await context.phase_manager.notify_error_occurred(msg, "TeamManager is not initialized.")
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=msg, exception_details="TeamManager is not initialized.")
+                )
             return
 
         try:
@@ -29,7 +31,13 @@ class ProcessUserMessageEventHandler(BaseAgentTeamEventHandler):
         except Exception as e:
             msg = f"Team '{context.team_id}': Node '{event.target_agent_name}' not found or failed to start. Cannot route message. Error: {e}"
             logger.error(msg, exc_info=True)
-            await context.phase_manager.notify_error_occurred(msg, f"Node '{event.target_agent_name}' not found or failed to start.")
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(
+                        error_message=msg,
+                        exception_details=f"Node '{event.target_agent_name}' not found or failed to start."
+                    )
+                )
             return
 
         if isinstance(target_node, Agent):
@@ -41,6 +49,7 @@ class ProcessUserMessageEventHandler(BaseAgentTeamEventHandler):
         else:
             msg = f"Target node '{event.target_agent_name}' is of an unsupported type: {type(target_node).__name__}"
             logger.error(f"Team '{context.team_id}': {msg}")
-            await context.phase_manager.notify_error_occurred(msg, "")
-
-        await context.phase_manager.notify_processing_complete_and_idle()
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=msg, exception_details="")
+                )

autobyteus/agent_team/handlers/tool_approval_team_event_handler.py

@@ -3,7 +3,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent_team.handlers.base_agent_team_event_handler import BaseAgentTeamEventHandler
-from autobyteus.agent_team.events.agent_team_events import ToolApprovalTeamEvent
+from autobyteus.agent_team.events.agent_team_events import ToolApprovalTeamEvent, AgentTeamErrorEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
@@ -21,7 +21,10 @@ class ToolApprovalTeamEventHandler(BaseAgentTeamEventHandler):
         if not team_manager:
             msg = f"Team '{team_id}': TeamManager not found. Cannot route approval for agent '{event.agent_name}'."
             logger.error(msg)
-            await context.phase_manager.notify_error_occurred(msg, "TeamManager is not initialized.")
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(error_message=msg, exception_details="TeamManager is not initialized.")
+                )
             return
 
         from autobyteus.agent.agent import Agent
@@ -29,7 +32,13 @@ class ToolApprovalTeamEventHandler(BaseAgentTeamEventHandler):
         if not isinstance(target_node, Agent):
             msg = f"Team '{team_id}': Target node '{event.agent_name}' for approval is not an agent."
             logger.error(msg)
-            await context.phase_manager.notify_error_occurred(msg, f"Node '{event.agent_name}' is not an agent.")
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(
+                        error_message=msg,
+                        exception_details=f"Node '{event.agent_name}' is not an agent."
+                    )
+                )
             return
         
         target_agent = target_node
@@ -37,7 +46,13 @@ class ToolApprovalTeamEventHandler(BaseAgentTeamEventHandler):
         if not target_agent:
             msg = f"Team '{team_id}': Target agent '{event.agent_name}' for approval not found or failed to start."
             logger.error(msg)
-            await context.phase_manager.notify_error_occurred(msg, f"Agent '{event.agent_name}' not found or failed to start.")
+            if context.state.input_event_queues:
+                await context.state.input_event_queues.enqueue_internal_system_event(
+                    AgentTeamErrorEvent(
+                        error_message=msg,
+                        exception_details=f"Agent '{event.agent_name}' not found or failed to start."
+                    )
+                )
             return
 
         logger.info(f"Team '{team_id}': Posting tool approval (Approved: {event.is_approved}) to agent '{event.agent_name}' for invocation '{event.tool_invocation_id}'.")

autobyteus/agent_team/runtime/agent_team_runtime.py

@@ -1,12 +1,20 @@
+
 # file: autobyteus/autobyteus/agent_team/runtime/agent_team_runtime.py
 import asyncio
 import logging
-from typing import TYPE_CHECKING, Callable, Optional
+import traceback
+from typing import TYPE_CHECKING, Optional
 
 from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
-from autobyteus.agent_team.phases.agent_team_phase_manager import AgentTeamPhaseManager
+from autobyteus.agent_team.status.agent_team_status_manager import AgentTeamStatusManager
+from autobyteus.agent_team.status.status_update_utils import apply_event_and_derive_status
 from autobyteus.agent_team.runtime.agent_team_worker import AgentTeamWorker
-from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent
+from autobyteus.agent_team.events.agent_team_events import (
+    BaseAgentTeamEvent,
+    AgentTeamErrorEvent,
+    AgentTeamStoppedEvent,
+    AgentTeamShutdownRequestedEvent,
+)
 from autobyteus.agent_team.streaming.agent_team_event_notifier import AgentTeamExternalEventNotifier
 from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
 
@@ -20,10 +28,11 @@ class AgentTeamRuntime:
     def __init__(self, context: AgentTeamContext, event_handler_registry: 'AgentTeamEventHandlerRegistry'):
         self.context = context
         self.notifier = AgentTeamExternalEventNotifier(team_id=self.context.team_id, runtime_ref=self)
-        self.phase_manager = AgentTeamPhaseManager(context=self.context, notifier=self.notifier)
         
-        # --- FIX: Set the phase_manager_ref on the context's state BEFORE creating the worker ---
-        self.context.state.phase_manager_ref = self.phase_manager
+        # Create the status manager before the worker so external notifications are available during bootstrap.
+        self.status_manager: AgentTeamStatusManager = AgentTeamStatusManager(self.context, self.notifier)
+        self.context.state.status_manager_ref = self.status_manager
+
         
         self._worker = AgentTeamWorker(self.context, event_handler_registry)
         
@@ -50,8 +59,22 @@ class AgentTeamRuntime:
             logger.info(f"AgentTeamRuntime '{team_id}': Worker thread completed.")
         except Exception as e:
             logger.error(f"AgentTeamRuntime '{team_id}': Worker thread terminated with exception: {e}", exc_info=True)
-        if not self.context.state.current_phase.is_terminal():
-             asyncio.run(self.phase_manager.notify_final_shutdown_complete())
+            if not self.context.current_status.is_terminal():
+                try:
+                    asyncio.run(self._apply_event_and_derive_status(
+                        AgentTeamErrorEvent(
+                            error_message="Worker thread exited unexpectedly.",
+                            exception_details=traceback.format_exc()
+                        )
+                    ))
+                except Exception as run_e:
+                    logger.critical(f"AgentTeamRuntime '{team_id}': Failed to emit derived error: {run_e}")
+
+        if not self.context.current_status.is_terminal():
+            try:
+                asyncio.run(self._apply_event_and_derive_status(AgentTeamStoppedEvent()))
+            except Exception as run_e:
+                logger.critical(f"AgentTeamRuntime '{team_id}': Failed to emit derived shutdown complete: {run_e}")
         
     def start(self):
         if self._worker.is_alive:
@@ -59,9 +82,14 @@ class AgentTeamRuntime:
         self._worker.start()
 
     async def stop(self, timeout: float = 10.0):
-        await self.phase_manager.notify_shutdown_initiated()
+        if not self._worker.is_alive and not self._worker._is_active:
+            if not self.context.current_status.is_terminal():
+                await self._apply_event_and_derive_status(AgentTeamStoppedEvent())
+            return
+
+        await self._apply_event_and_derive_status(AgentTeamShutdownRequestedEvent())
         await self._worker.stop(timeout=timeout)
-        await self.phase_manager.notify_final_shutdown_complete()
+        await self._apply_event_and_derive_status(AgentTeamStoppedEvent())
 
     async def submit_event(self, event: BaseAgentTeamEvent):
         if not self._worker.is_alive:
@@ -77,6 +105,9 @@ class AgentTeamRuntime:
         future = self._worker.schedule_coroutine(_coro_factory)
         await asyncio.wrap_future(future)
 
+    async def _apply_event_and_derive_status(self, event: BaseAgentTeamEvent) -> None:
+        await apply_event_and_derive_status(event, self.context)
+
     @property
     def is_running(self) -> bool:
         return self._worker.is_alive

autobyteus/agent_team/runtime/agent_team_worker.py

@@ -5,8 +5,18 @@ import concurrent.futures
 from typing import TYPE_CHECKING, Optional, Callable, Awaitable, Any
 
 from autobyteus.agent_team.events.agent_team_event_dispatcher import AgentTeamEventDispatcher
+from autobyteus.agent_team.events.agent_team_events import (
+    AgentTeamBootstrapStartedEvent,
+    AgentTeamReadyEvent,
+    AgentTeamErrorEvent,
+    AgentTeamStoppedEvent,
+)
+from autobyteus.agent_team.events.agent_team_input_event_queue_manager import AgentTeamInputEventQueueManager
+from autobyteus.agent_team.events.event_store import AgentTeamEventStore
 from autobyteus.agent_team.bootstrap_steps.agent_team_bootstrapper import AgentTeamBootstrapper
 from autobyteus.agent_team.shutdown_steps.agent_team_shutdown_orchestrator import AgentTeamShutdownOrchestrator
+from autobyteus.agent_team.status.status_deriver import AgentTeamStatusDeriver
+from autobyteus.agent_team.status.status_update_utils import apply_event_and_derive_status
 from autobyteus.agent.runtime.agent_thread_pool_manager import AgentThreadPoolManager
 
 if TYPE_CHECKING:
@@ -19,8 +29,11 @@ class AgentTeamWorker:
     """Encapsulates the core event processing loop for an agent team."""
     def __init__(self, context: 'AgentTeamContext', event_handler_registry: 'AgentTeamEventHandlerRegistry'):
         self.context = context
-        self.phase_manager = self.context.phase_manager
-        self.event_dispatcher = AgentTeamEventDispatcher(event_handler_registry, self.phase_manager)
+        self.status_manager = self.context.status_manager
+        if not self.status_manager:  # pragma: no cover
+            raise ValueError(f"AgentTeamWorker for '{self.context.team_id}': AgentTeamStatusManager not found.")
+
+        self.event_dispatcher = AgentTeamEventDispatcher(event_handler_registry)
         
         self._thread_pool_manager = AgentThreadPoolManager()
         self._thread_future: Optional[concurrent.futures.Future] = None
@@ -31,6 +44,28 @@ class AgentTeamWorker:
         self._done_callbacks: list[Callable[[concurrent.futures.Future], None]] = []
         logger.info(f"AgentTeamWorker initialized for team '{self.context.team_id}'.")
 
+    async def _runtime_init(self) -> bool:
+        team_id = self.context.team_id
+        if self.context.state.event_store is None:
+            self.context.state.event_store = AgentTeamEventStore(team_id=team_id)
+            logger.info(f"Team '{team_id}': Runtime init completed (event store initialized).")
+
+        if self.context.state.status_deriver is None:
+            self.context.state.status_deriver = AgentTeamStatusDeriver()
+            logger.info(f"Team '{team_id}': Runtime init completed (status deriver initialized).")
+
+        if self.context.state.input_event_queues is not None:
+            logger.debug(f"Team '{team_id}': Runtime init skipped; input event queues already initialized.")
+            return True
+
+        try:
+            self.context.state.input_event_queues = AgentTeamInputEventQueueManager()
+            logger.info(f"Team '{team_id}': Runtime init completed (input queues initialized).")
+            return True
+        except Exception as e:
+            logger.critical(f"Team '{team_id}': Runtime init failed while initializing input queues: {e}", exc_info=True)
+            return False
+
     def get_worker_loop(self) -> Optional[asyncio.AbstractEventLoop]:
         """Returns the worker's event loop if it's running."""
         return self._worker_loop if self._worker_loop and self._worker_loop.is_running() else None
@@ -69,11 +104,27 @@ class AgentTeamWorker:
             self._is_active = False
 
     async def async_run(self):
+        team_id = self.context.team_id
+        if not await self._runtime_init():
+            logger.critical(f"Team '{team_id}': Runtime init failed. Shutting down.")
+            await apply_event_and_derive_status(
+                AgentTeamErrorEvent(error_message="Runtime init failed.", exception_details="Failed to initialize event store or queues."),
+                self.context
+            )
+            return
+
         bootstrapper = AgentTeamBootstrapper()
-        if not await bootstrapper.run(self.context, self.phase_manager):
-            logger.critical(f"Team '{self.context.team_id}' failed to initialize. Shutting down.")
+        await self.event_dispatcher.dispatch(AgentTeamBootstrapStartedEvent(), self.context)
+        if not await bootstrapper.run(self.context):
+            logger.critical(f"Team '{team_id}' failed to initialize. Shutting down.")
+            await self.event_dispatcher.dispatch(
+                AgentTeamErrorEvent(error_message="Bootstrap failed.", exception_details="Bootstrapper returned failure."),
+                self.context
+            )
             return
 
+        await self.event_dispatcher.dispatch(AgentTeamReadyEvent(), self.context)
+
         logger.info(f"Team '{self.context.team_id}' entering main event loop.")
         while not self._async_stop_event.is_set():
             try:
@@ -103,7 +154,20 @@ class AgentTeamWorker:
             return
         self._stop_initiated = True
         if self._worker_loop:
-            self._worker_loop.call_soon_threadsafe(self._async_stop_event.set)
+            def _coro_factory():
+                async def _signal_coro():
+                    if self._async_stop_event and not self._async_stop_event.is_set():
+                        self._async_stop_event.set()
+                        if self.context.state.input_event_queues:
+                            await self.context.state.input_event_queues.enqueue_internal_system_event(
+                                AgentTeamStoppedEvent()
+                            )
+                return _signal_coro()
+            try:
+                future = self.schedule_coroutine(_coro_factory)
+                future.result(timeout=max(1.0, timeout - 1))
+            except Exception as e:
+                logger.error(f"Team '{self.context.team_id}': Error signaling stop event: {e}", exc_info=True)
         if self._thread_future:
             try:
                 # FIX: Use asyncio.wait_for() to handle the timeout correctly.

autobyteus/agent_team/status/__init__.py

@@ -0,0 +1,14 @@
+"""
+This package contains components for defining and managing agent team operational status.
+"""
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+from autobyteus.agent_team.status.agent_team_status_manager import AgentTeamStatusManager
+from autobyteus.agent_team.status.status_deriver import AgentTeamStatusDeriver
+from autobyteus.agent_team.status.status_update_utils import apply_event_and_derive_status
+
+__all__ = [
+    "AgentTeamStatus",
+    "AgentTeamStatusManager",
+    "AgentTeamStatusDeriver",
+    "apply_event_and_derive_status",
+]

autobyteus/agent_team/status/agent_team_status.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+class AgentTeamStatus(str, Enum):
+    """Defines the operational status of an AgentTeam."""
+    UNINITIALIZED = "uninitialized"
+    BOOTSTRAPPING = "bootstrapping"
+    IDLE = "idle"
+    PROCESSING = "processing"
+    SHUTTING_DOWN = "shutting_down"
+    SHUTDOWN_COMPLETE = "shutdown_complete"
+    ERROR = "error"
+
+    def is_terminal(self) -> bool:
+        """Checks if the status is a terminal state."""
+        return self in [AgentTeamStatus.SHUTDOWN_COMPLETE, AgentTeamStatus.ERROR]
+
+    def __str__(self) -> str:
+        return self.value

autobyteus/agent_team/status/agent_team_status_manager.py

@@ -0,0 +1,33 @@
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.streaming.agent_team_event_notifier import AgentTeamExternalEventNotifier
+
+logger = logging.getLogger(__name__)
+
+class AgentTeamStatusManager:
+    """
+    Emits external notifications for status updates derived from events.
+    The status itself is owned by the event stream projection.
+    """
+    def __init__(self, context: 'AgentTeamContext', notifier: 'AgentTeamExternalEventNotifier'):
+        if notifier is None:
+            raise ValueError("AgentTeamStatusManager requires a notifier.")
+        self.context = context
+        self.notifier = notifier
+        if not isinstance(self.context.state.current_status, AgentTeamStatus):
+            self.context.state.current_status = AgentTeamStatus.UNINITIALIZED
+        logger.debug(f"AgentTeamStatusManager initialized for team '{context.team_id}'.")
+
+    async def emit_status_update(self,
+                                 old_status: AgentTeamStatus,
+                                 new_status: AgentTeamStatus,
+                                 additional_data: Optional[dict] = None) -> None:
+        if old_status == new_status:
+            return
+        logger.info(f"Team '{self.context.team_id}' updating status from {old_status.value} to {new_status.value}.")
+        self.notifier.notify_status_updated(new_status, old_status, additional_data)

autobyteus/agent_team/status/status_deriver.py

@@ -0,0 +1,62 @@
+# file: autobyteus/autobyteus/agent_team/status/status_deriver.py
+import logging
+from typing import Optional, Tuple, TYPE_CHECKING
+
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+from autobyteus.agent_team.events.agent_team_events import (
+    AgentTeamBootstrapStartedEvent,
+    AgentTeamReadyEvent,
+    AgentTeamIdleEvent,
+    AgentTeamShutdownRequestedEvent,
+    AgentTeamStoppedEvent,
+    AgentTeamErrorEvent,
+    OperationalAgentTeamEvent,
+)
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent
+
+logger = logging.getLogger(__name__)
+
+
+class AgentTeamStatusDeriver:
+    """
+    Derives agent team status from an event stream.
+    """
+    def __init__(self, initial_status: AgentTeamStatus = AgentTeamStatus.UNINITIALIZED):
+        self._current_status = initial_status
+        logger.debug(f"AgentTeamStatusDeriver initialized with status '{initial_status.value}'.")
+
+    @property
+    def current_status(self) -> AgentTeamStatus:
+        return self._current_status
+
+    def apply(self, event: 'BaseAgentTeamEvent', context: Optional['AgentTeamContext'] = None) -> Tuple[AgentTeamStatus, AgentTeamStatus]:
+        old_status = self._current_status
+        new_status = self._reduce(event, old_status, context)
+        self._current_status = new_status
+        return old_status, new_status
+
+    def _reduce(self, event: 'BaseAgentTeamEvent', current_status: AgentTeamStatus, context: Optional['AgentTeamContext']) -> AgentTeamStatus:
+        if isinstance(event, AgentTeamBootstrapStartedEvent):
+            return AgentTeamStatus.BOOTSTRAPPING
+        if isinstance(event, AgentTeamReadyEvent):
+            return AgentTeamStatus.IDLE
+        if isinstance(event, AgentTeamIdleEvent):
+            return AgentTeamStatus.IDLE
+        if isinstance(event, AgentTeamShutdownRequestedEvent):
+            if current_status == AgentTeamStatus.ERROR:
+                return current_status
+            return AgentTeamStatus.SHUTTING_DOWN
+        if isinstance(event, AgentTeamStoppedEvent):
+            if current_status == AgentTeamStatus.ERROR:
+                return current_status
+            return AgentTeamStatus.SHUTDOWN_COMPLETE
+        if isinstance(event, AgentTeamErrorEvent):
+            return AgentTeamStatus.ERROR
+
+        if isinstance(event, OperationalAgentTeamEvent):
+            return AgentTeamStatus.PROCESSING
+
+        return current_status

autobyteus/agent_team/status/status_update_utils.py

@@ -0,0 +1,42 @@
+# file: autobyteus/autobyteus/agent_team/status/status_update_utils.py
+import logging
+from typing import Optional, Tuple, TYPE_CHECKING
+
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
+from autobyteus.agent_team.events.agent_team_events import AgentTeamErrorEvent
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+    from autobyteus.agent_team.events.agent_team_events import BaseAgentTeamEvent
+
+logger = logging.getLogger(__name__)
+
+
+def build_status_update_data(event: 'BaseAgentTeamEvent',
+                             new_status: AgentTeamStatus) -> Optional[dict]:
+    if new_status == AgentTeamStatus.ERROR and isinstance(event, AgentTeamErrorEvent):
+        return {"error_message": event.error_message}
+    return None
+
+
+async def apply_event_and_derive_status(event: 'BaseAgentTeamEvent',
+                                        context: 'AgentTeamContext') -> Tuple[AgentTeamStatus, AgentTeamStatus]:
+    if context.state.event_store:
+        try:
+            context.state.event_store.append(event)
+        except Exception as exc:  # pragma: no cover
+            logger.error(f"Failed to append team event to store: {exc}", exc_info=True)
+
+    if not context.state.status_deriver:
+        return context.current_status, context.current_status
+
+    old_status, new_status = context.state.status_deriver.apply(event, context)
+    if old_status != new_status:
+        context.current_status = new_status
+        additional_data = build_status_update_data(event, new_status)
+        if context.status_manager:
+            await context.status_manager.emit_status_update(
+                old_status, new_status, additional_data=additional_data
+            )
+
+    return old_status, new_status