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

autobyteus/agent_team/streaming/team_event_bridge.py

@@ -0,0 +1,50 @@
+# file: autobyteus/autobyteus/agent_team/streaming/team_event_bridge.py
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.agent_team import AgentTeam
+    from autobyteus.agent_team.streaming.agent_team_event_notifier import AgentTeamExternalEventNotifier
+
+logger = logging.getLogger(__name__)
+
+class TeamEventBridge:
+    """
+    A dedicated component that bridges events from a sub-team's event stream
+    to the parent team's notifier.
+    """
+    def __init__(self, sub_team: 'AgentTeam', sub_team_node_name: str, parent_notifier: 'AgentTeamExternalEventNotifier', loop: asyncio.AbstractEventLoop):
+        self._sub_team = sub_team
+        self._sub_team_node_name = sub_team_node_name
+        self._parent_notifier = parent_notifier
+        self._stream = AgentTeamEventStream(sub_team)
+        self._task: asyncio.Task = loop.create_task(self._run())
+        logger.info(f"TeamEventBridge created and task started for sub-team '{sub_team_node_name}'.")
+
+    async def _run(self):
+        """The background task that consumes from the sub-team stream and re-publishes."""
+        try:
+            async for event in self._stream.all_events():
+                # Re-broadcast the event to the parent, adding the sub-team context.
+                self._parent_notifier.publish_sub_team_event(self._sub_team_node_name, event)
+        except asyncio.CancelledError:
+            logger.info(f"TeamEventBridge task for '{self._sub_team_node_name}' was cancelled.")
+        except Exception as e:
+            logger.error(f"Error in TeamEventBridge for '{self._sub_team_node_name}': {e}", exc_info=True)
+        finally:
+            logger.debug(f"TeamEventBridge task for '{self._sub_team_node_name}' is finishing.")
+
+    async def cancel(self):
+        """Gracefully stops the bridge."""
+        logger.info(f"Cancelling TeamEventBridge for '{self._sub_team_node_name}'.")
+        if not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass # Expected
+        await self._stream.close()
+        logger.info(f"TeamEventBridge for '{self._sub_team_node_name}' cancelled successfully.")

autobyteus/agent_team/task_notification/__init__.py

@@ -0,0 +1,11 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/__init__.py
+"""
+This package contains components for automatically notifying agents of runnable tasks.
+"""
+from .system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
+from .task_notification_mode import TaskNotificationMode
+
+__all__ = [
+    "SystemEventDrivenAgentTaskNotifier",
+    "TaskNotificationMode",
+]

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

@@ -0,0 +1,164 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py
+import asyncio
+import logging
+from typing import Set, Any, TYPE_CHECKING, List, Union
+
+from autobyteus.events.event_types import EventType
+from autobyteus.agent_team.events import ProcessUserMessageEvent
+from autobyteus.agent.message import AgentInputUserMessage
+from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.task_plan import Task
+
+if TYPE_CHECKING:
+    from autobyteus.task_management.base_task_board import BaseTaskBoard
+    from autobyteus.agent_team.context.team_manager import TeamManager
+
+logger = logging.getLogger(__name__)
+
+class SystemEventDrivenAgentTaskNotifier:
+    """
+    An internal component that monitors a TaskBoard and automatically sends
+    notifications to agents when their assigned tasks become runnable.
+    """
+    def __init__(self, task_board: 'BaseTaskBoard', team_manager: 'TeamManager'):
+        """
+        Initializes the SystemEventDrivenAgentTaskNotifier.
+
+        Args:
+            task_board: The team's shared task board instance.
+            team_manager: The team's manager for submitting notification events.
+        """
+        if not task_board or not team_manager:
+            raise ValueError("TaskBoard and TeamManager are required for the notifier.")
+            
+        self._task_board = task_board
+        self._team_manager = team_manager
+        self._dispatched_task_ids: Set[str] = set()
+        logger.info(f"SystemEventDrivenAgentTaskNotifier initialized for team '{self._team_manager.team_id}'.")
+
+    def start_monitoring(self):
+        """
+        Subscribes to task board events to begin monitoring for runnable tasks.
+        This should be called once during the agent team's bootstrap process.
+        """
+        self._task_board.subscribe(
+            EventType.TASK_BOARD_PLAN_PUBLISHED,
+            self._handle_task_board_update
+        )
+        self._task_board.subscribe(
+            EventType.TASK_BOARD_STATUS_UPDATED,
+            self._handle_task_board_update
+        )
+        logger.info(f"Team '{self._team_manager.team_id}': Task notifier is now monitoring TaskBoard events.")
+
+    async def _handle_task_board_update(self, payload: Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent], **kwargs):
+        """
+        Asynchronous event handler triggered by the task board. It uses the event
+        payload to decide when to check for and notify agents of newly runnable tasks.
+        """
+        if isinstance(payload, TaskPlanPublishedEvent):
+            logger.info(f"Team '{self._team_manager.team_id}': New task plan detected. Resetting dispatched tasks and checking for initial runnable tasks.")
+            self._dispatched_task_ids.clear()
+            await self._scan_and_notify_all_runnable_tasks()
+        
+        elif isinstance(payload, TaskStatusUpdatedEvent):
+            # Only trigger a check for dependent tasks if a task has been completed,
+            # as this is the only status change that can unblock dependent tasks.
+            if payload.new_status == TaskStatus.COMPLETED:
+                logger.info(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' completed. Checking for newly unblocked dependent tasks.")
+                await self._check_and_notify_dependent_tasks(payload.task_id)
+            else:
+                logger.debug(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' status updated to '{payload.new_status.value}'. No dependent task check needed.")
+        else:
+            # This case should ideally not be hit with the new strong typing, but is kept as a safeguard.
+            logger.warning(f"Team '{self._team_manager.team_id}': Task notifier received an unhandled payload type: {type(payload)}")
+
+
+    async def _check_and_notify_dependent_tasks(self, completed_task_id: str):
+        """
+        Finds tasks that depend on the completed task and notifies their assignees
+        if all of their other dependencies are also met.
+        """
+        if not getattr(self._task_board, 'current_plan', None):
+            return
+
+        all_tasks = self._task_board.current_plan.tasks
+        task_statuses = getattr(self._task_board, 'task_statuses', {})
+
+        for child_task in all_tasks:
+            # Find tasks that are direct children of the completed task
+            if completed_task_id in child_task.dependencies:
+                # Now, check if this child task is fully runnable (all its parents are done)
+                all_deps_met = all(
+                    task_statuses.get(dep_id) == TaskStatus.COMPLETED for dep_id in child_task.dependencies
+                )
+                
+                if all_deps_met and child_task.task_id not in self._dispatched_task_ids:
+                    await self._dispatch_notification_for_task(child_task)
+
+    async def _scan_and_notify_all_runnable_tasks(self):
+        """
+        Scans the entire board for any runnable tasks. Used for initial plan loading.
+        """
+        try:
+            runnable_tasks = self._task_board.get_next_runnable_tasks()
+            for task in runnable_tasks:
+                if task.task_id not in self._dispatched_task_ids:
+                    await self._dispatch_notification_for_task(task)
+        except Exception as e:
+            logger.error(f"Team '{self._team_manager.team_id}': Error during full scan for runnable tasks: {e}", exc_info=True)
+    
+    async def _dispatch_notification_for_task(self, task: Task):
+        """
+        Constructs and sends a context-rich notification for a single runnable task
+        by treating it as a user message to trigger the full processing pipeline.
+        It tags the message with metadata to indicate its system origin.
+        """
+        try:
+            team_id = self._team_manager.team_id
+            logger.info(f"Team '{team_id}': Dispatching notification for runnable task '{task.task_name}' to assignee '{task.assignee_name}'.")
+            
+            context_from_parents = []
+            if task.dependencies:
+                parent_task_deliverables_info = []
+                for dep_id in task.dependencies:
+                    parent_task = getattr(self._task_board, '_task_map', {}).get(dep_id)
+                    if parent_task and parent_task.file_deliverables:
+                        deliverables_str = "\n".join(
+                            [f"  - File: {d.file_path}, Summary: {d.summary}" for d in parent_task.file_deliverables]
+                        )
+                        parent_task_deliverables_info.append(
+                            f"The parent task '{parent_task.task_name}' produced the following deliverables:\n{deliverables_str}"
+                        )
+                
+                if parent_task_deliverables_info:
+                    context_from_parents.append(
+                        "Your task is now unblocked. Here is the context from the completed parent task(s):\n" +
+                        "\n\n".join(parent_task_deliverables_info)
+                    )
+
+            message_parts: List[str] = [f"Your task '{task.task_name}' is now ready to start."]
+            if context_from_parents:
+                message_parts.extend(context_from_parents)
+            
+            message_parts.append(f"\nYour task description:\n{task.description}")
+            
+            content = "\n\n".join(message_parts)
+            
+            # Create the user message with metadata indicating its origin.
+            user_message = AgentInputUserMessage(
+                content=content,
+                metadata={'source': 'system_task_notifier'}
+            )
+            event = ProcessUserMessageEvent(
+                user_message=user_message,
+                target_agent_name=task.assignee_name
+            )
+
+            # Use the existing method for dispatching user messages.
+            await self._team_manager.dispatch_user_message_to_agent(event)
+            self._dispatched_task_ids.add(task.task_id)
+
+        except Exception as e:
+            logger.error(f"Team '{self._team_manager.team_id}': Failed to dispatch notification for task '{task.task_id}': {e}", exc_info=True)

autobyteus/agent_team/task_notification/task_notification_mode.py

@@ -0,0 +1,24 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/task_notification_mode.py
+"""
+Defines the enum for controlling how task notifications are handled in an agent team.
+"""
+from enum import Enum
+
+class TaskNotificationMode(str, Enum):
+    """
+    Enumerates the modes for handling task notifications within an agent team.
+    """
+    AGENT_MANUAL_NOTIFICATION = "agent_manual_notification"
+    """
+    In this mode, an agent (typically the coordinator) is responsible for
+    manually sending notifications to other agents to start their tasks.
+    """
+    
+    SYSTEM_EVENT_DRIVEN = "system_event_driven"
+    """
+    In this mode, the agent team framework automatically monitors the TaskBoard
+    and sends notifications to agents when their assigned tasks become runnable.
+    """
+
+    def __str__(self) -> str:
+        return self.value

autobyteus/agent_team/utils/__init__.py

@@ -0,0 +1,9 @@
+# file: autobyteus/autobyteus/agent_team/utils/__init__.py
+"""
+Utility functions for interacting with agent teams.
+"""
+from .wait_for_idle import wait_for_team_to_be_idle
+
+__all__ = [
+    "wait_for_team_to_be_idle",
+]

autobyteus/agent_team/utils/wait_for_idle.py

@@ -0,0 +1,46 @@
+# file: autobyteus/autobyteus/agent_team/utils/wait_for_idle.py
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
+from autobyteus.agent_team.phases.agent_team_operational_phase import AgentTeamOperationalPhase
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.agent_team import AgentTeam
+
+logger = logging.getLogger(__name__)
+
+async def _wait_loop(streamer: AgentTeamEventStream, team_id: str):
+    """Internal helper to listen for the IDLE or ERROR event."""
+    async for event in streamer.all_events():
+        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.IDLE:
+            logger.info(f"Team '{team_id}' has become idle.")
+            return
+        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.ERROR:
+             error_message = f"Team '{team_id}' entered an error state while waiting for idle: {event.data.error_message}"
+             logger.error(error_message)
+             raise RuntimeError(error_message)
+
+async def wait_for_team_to_be_idle(team: 'AgentTeam', timeout: float = 60.0):
+    """
+    Waits for an agent team to complete its bootstrapping and enter the IDLE state.
+
+    Args:
+        team: The agent team instance to monitor.
+        timeout: The maximum time in seconds to wait.
+
+    Raises:
+        asyncio.TimeoutError: If the team does not become idle within the timeout period.
+        RuntimeError: If the team enters an error state.
+    """
+    if team.get_current_phase() == AgentTeamOperationalPhase.IDLE:
+        return
+    
+    logger.info(f"Waiting for team '{team.team_id}' to become idle (timeout: {timeout}s)...")
+    
+    streamer = AgentTeamEventStream(team)
+    try:
+        await asyncio.wait_for(_wait_loop(streamer, team.team_id), timeout=timeout)
+    finally:
+        await streamer.close()

autobyteus/cli/__init__.py

@@ -6,6 +6,6 @@ from .agent_cli import run
 from .cli_display import InteractiveCLIDisplay
 
 __all__ = [
-    "run", 
+    "run",
     "InteractiveCLIDisplay",
 ]

autobyteus/cli/agent_team_tui/__init__.py

@@ -0,0 +1,4 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/__init__.py
+"""
+A Textual-based TUI for interacting with Agent Teams.
+"""

autobyteus/cli/agent_team_tui/app.py

@@ -0,0 +1,210 @@
+# file: autobyteus/autobyteus/cli/agent_team_tui/app.py
+"""
+The main Textual application class for the agent team TUI. This class orchestrates
+the UI by reacting to changes in a central state store.
+"""
+import asyncio
+import logging
+from typing import Dict, Optional, Any
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Header, Static
+from textual.reactive import reactive
+
+from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent_team.streaming.agent_team_event_stream import AgentTeamEventStream
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent.streaming.stream_events import StreamEventType as AgentStreamEventType
+from autobyteus.agent.streaming.stream_event_payloads import AssistantChunkData
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, AgentTeamPhaseTransitionData
+
+from .state import TUIStateStore
+from .widgets.agent_list_sidebar import AgentListSidebar
+from .widgets.focus_pane import FocusPane
+from .widgets.status_bar import StatusBar
+
+logger = logging.getLogger(__name__)
+
+class AgentTeamApp(App):
+    """A Textual TUI for interacting with an agent team, built around a central state store."""
+
+    TITLE = "AutoByteus"
+    CSS_PATH = "app.css"
+    BINDINGS = [
+        ("d", "toggle_dark", "Toggle Dark Mode"),
+        ("q", "quit", "Quit"),
+    ]
+
+    focused_node_data: reactive[Optional[Dict[str, Any]]] = reactive(None)
+    # The store_version property will trigger UI updates for the sidebar.
+    store_version: reactive[int] = reactive(0)
+
+    def __init__(self, team: AgentTeam, **kwargs):
+        super().__init__(**kwargs)
+        self.team = team
+        self.store = TUIStateStore(team=self.team)
+        self.team_stream: Optional[AgentTeamEventStream] = None
+        # Flag to indicate that the UI needs an update, used for throttling.
+        self._ui_update_pending = False
+
+    def compose(self) -> ComposeResult:
+        yield Header(id="app-header", name="AutoByteus Mission Control")
+        with Horizontal(id="main-container"):
+            yield AgentListSidebar(id="sidebar")
+            yield FocusPane(id="focus-pane")
+        yield StatusBar()
+
+    async def on_mount(self) -> None:
+        """Start background tasks when the app is mounted."""
+        self.team.start()
+        self.team_stream = AgentTeamEventStream(self.team)
+        
+        # Initialize the UI with the starting state
+        initial_tree = self.store.get_tree_data()
+        initial_focus_node = initial_tree.get(self.team.name)
+        
+        self.store.set_focused_node(initial_focus_node)
+        self.focused_node_data = initial_focus_node
+        self.store_version = self.store.version # Trigger initial render
+        
+        self.run_worker(self._listen_for_team_events(), name="team_listener")
+        
+        # Set up a timer to run the throttled UI updater at ~15 FPS.
+        self.set_interval(1 / 15, self._throttled_ui_updater, name="ui_updater")
+        logger.info("Agent Team TUI mounted, team listener and throttled UI updater started.")
+
+    async def on_unmount(self) -> None:
+        if self.team and self.team.is_running:
+            await self.team.stop()
+
+    def _throttled_ui_updater(self) -> None:
+        """
+        Periodically checks if the UI state is dirty and, if so, triggers
+        reactive updates. It also flushes streaming buffers from the focus pane.
+        """
+        focus_pane = self.query_one(FocusPane)
+        if self._ui_update_pending:
+            self._ui_update_pending = False
+            # This is the throttled trigger for the async watcher.
+            self.store_version = self.store.version
+        
+        # Always flush the focus pane's streaming buffer for smooth text rendering.
+        focus_pane.flush_stream_buffers()
+
+    async def _listen_for_team_events(self) -> None:
+        """A background worker that forwards team events to the state store and updates the UI."""
+        if not self.team_stream: return
+        try:
+            async for event in self.team_stream.all_events():
+                # 1. Always update the central state store immediately.
+                self.store.process_event(event)
+                
+                # 2. Mark the UI as needing an update for the throttled components.
+                self._ui_update_pending = True
+                
+                # 3. Handle real-time, incremental updates directly.
+                if isinstance(event.data, AgentEventRebroadcastPayload):
+                    payload = event.data
+                    agent_name = payload.agent_name
+                    agent_event = payload.agent_event
+                    focus_pane = self.query_one(FocusPane)
+                    
+                    is_currently_focused = (focus_pane._focused_node_data and focus_pane._focused_node_data.get('name') == agent_name)
+
+                    if is_currently_focused:
+                        await focus_pane.add_agent_event(agent_event)
+
+        except asyncio.CancelledError:
+            logger.info("Agent team event listener task was cancelled.")
+        except Exception:
+            logger.error("Critical error in agent team TUI event listener", exc_info=True)
+        finally:
+            if self.team_stream: await self.team_stream.close()
+
+    # --- Reactive Watchers ---
+
+    async def watch_store_version(self, new_version: int):
+        """
+        Reacts to changes in the store version.
+        """
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+
+        tree_data = self.store.get_tree_data()
+        agent_phases = self.store._agent_phases
+        team_phases = self.store._team_phases
+        speaking_agents = self.store._speaking_agents
+        
+        sidebar.update_tree(tree_data, agent_phases, team_phases, speaking_agents)
+        
+        focused_data = self.focused_node_data
+        if focused_data and focused_data.get("type") in ['team', 'subteam']:
+            node_name = focused_data['name']
+            task_plan = self.store.get_task_board_plan(node_name)
+            task_statuses = self.store.get_task_board_statuses(node_name)
+            await focus_pane.update_content(
+                node_data=focused_data,
+                history=[], # No history for teams
+                pending_approval=None,
+                all_agent_phases=agent_phases,
+                all_team_phases=team_phases,
+                task_plan=task_plan,
+                task_statuses=task_statuses
+            )
+        elif focused_data and focused_data.get("type") == 'agent':
+            focus_pane.update_current_node_status(agent_phases, team_phases)
+
+
+    async def watch_focused_node_data(self, new_node_data: Optional[Dict[str, Any]]):
+        """Reacts to changes in which node is focused. Primarily used for full pane reloads on user click."""
+        if not new_node_data: return
+        
+        node_name = new_node_data['name']
+        node_type = new_node_data['type']
+
+        history = self.store.get_history_for_node(node_name, node_type)
+        pending_approval = self.store.get_pending_approval_for_agent(node_name) if node_type == 'agent' else None
+        
+        task_plan = None
+        task_statuses = None
+        if node_type in ['team', 'subteam']:
+            task_plan = self.store.get_task_board_plan(node_name)
+            task_statuses = self.store.get_task_board_statuses(node_name)
+        
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+        
+        await focus_pane.update_content(
+            node_data=new_node_data,
+            history=history,
+            pending_approval=pending_approval,
+            all_agent_phases=self.store._agent_phases,
+            all_team_phases=self.store._team_phases,
+            task_plan=task_plan,
+            task_statuses=task_statuses
+        )
+        
+        sidebar.update_selection(node_name)
+
+    # --- Event Handlers (Actions) ---
+
+    def on_agent_list_sidebar_node_selected(self, message: AgentListSidebar.NodeSelected):
+        """Handles a node being selected by updating the store and the app's reactive state."""
+        self.store.set_focused_node(message.node_data)
+        self.focused_node_data = message.node_data
+
+    async def on_focus_pane_message_submitted(self, message: FocusPane.MessageSubmitted):
+        """Dispatches a user message to the backend model."""
+        user_message = AgentInputUserMessage(content=message.text)
+        await self.team.post_message(message=user_message, target_agent_name=message.agent_name)
+
+    async def on_focus_pane_approval_submitted(self, message: FocusPane.ApprovalSubmitted):
+        """Dispatches a tool approval to the backend model."""
+        self.store.clear_pending_approval(message.agent_name)
+        await self.team.post_tool_execution_approval(
+            agent_name=message.agent_name,
+            tool_invocation_id=message.invocation_id,
+            is_approved=message.is_approved,
+            reason=message.reason,
+        )