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

autobyteus/agent_team/streaming/agent_team_stream_events.py

@@ -5,13 +5,13 @@ from typing import Literal, Union
 from pydantic import BaseModel, Field, model_validator
 
 from .agent_team_stream_event_payloads import (
-    AgentTeamPhaseTransitionData, AgentEventRebroadcastPayload, 
+    AgentTeamStatusUpdateData, AgentEventRebroadcastPayload,
     SubTeamEventRebroadcastPayload, TaskPlanEventPayload
 )
 from autobyteus.task_management.events import BaseTaskPlanEvent
 
 # A union of all possible payloads for a "TEAM" sourced event.
-TeamSpecificPayload = Union[AgentTeamPhaseTransitionData]
+TeamSpecificPayload = Union[AgentTeamStatusUpdateData]
 
 # The top-level discriminated union for the main event stream's payload.
 AgentTeamStreamDataPayload = Union[TeamSpecificPayload, AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, TaskPlanEventPayload]
@@ -32,7 +32,7 @@ class AgentTeamStreamEvent(BaseModel):
         is_sub_team_payload = isinstance(self.data, SubTeamEventRebroadcastPayload)
 
         is_team_event = self.event_source_type == "TEAM"
-        is_team_payload = isinstance(self.data, AgentTeamPhaseTransitionData)
+        is_team_payload = isinstance(self.data, AgentTeamStatusUpdateData)
         
         is_task_plan_event = self.event_source_type == "TASK_PLAN"
         is_task_plan_payload = isinstance(self.data, BaseTaskPlanEvent)

autobyteus/agent_team/system_prompt_processor/__init__.py

@@ -0,0 +1,6 @@
+# file: autobyteus/autobyteus/agent_team/system_prompt_processor/__init__.py
+from .team_manifest_injector_processor import TeamManifestInjectorProcessor
+
+__all__ = [
+    "TeamManifestInjectorProcessor",
+]

autobyteus/agent_team/system_prompt_processor/team_manifest_injector_processor.py

@@ -0,0 +1,76 @@
+# file: autobyteus/autobyteus/agent_team/system_prompt_processor/team_manifest_injector_processor.py
+import logging
+from typing import Dict, List, TYPE_CHECKING
+
+from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPromptProcessor
+from autobyteus.agent_team.context import AgentTeamConfig
+
+if TYPE_CHECKING:
+    from autobyteus.tools.base_tool import BaseTool
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context.agent_team_context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+
+class TeamManifestInjectorProcessor(BaseSystemPromptProcessor):
+    """
+    Injects a team manifest into the system prompt for agents that belong to a team.
+    If the prompt contains {{team}}, the placeholder is replaced. Otherwise, the
+    manifest is appended as a dedicated section.
+    """
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "TeamManifestInjector"
+
+    @classmethod
+    def get_order(cls) -> int:
+        return 450
+
+    def process(
+        self,
+        system_prompt: str,
+        tool_instances: Dict[str, 'BaseTool'],
+        agent_id: str,
+        context: 'AgentContext',
+    ) -> str:
+        team_context = context.custom_data.get("team_context")
+        if team_context is None:
+            logger.debug(f"Agent '{agent_id}': No team_context found; skipping team manifest injection.")
+            return system_prompt
+
+        manifest = self._generate_team_manifest(team_context, exclude_name=context.config.name)
+
+        if "{{team}}" in system_prompt:
+            logger.info(f"Agent '{agent_id}': Replacing {{team}} placeholder with team manifest.")
+            return system_prompt.replace("{{team}}", manifest)
+
+        logger.info(f"Agent '{agent_id}': Appending team manifest to system prompt.")
+        return system_prompt + "\n\n## Team Manifest\n\n" + manifest
+
+    def _generate_team_manifest(self, context: 'AgentTeamContext', exclude_name: str) -> str:
+        """
+        Builds a manifest string of all team members except the given agent.
+        Includes sub-teams so agents see the full collaboration surface.
+        """
+        prompt_parts: List[str] = []
+
+        for node in sorted(list(context.config.nodes), key=lambda n: n.name):
+            if node.name == exclude_name:
+                continue
+
+            node_def = node.node_definition
+            description = "No description available."
+
+            if hasattr(node_def, "description") and isinstance(node_def.description, str):
+                description = node_def.description
+            elif isinstance(node_def, AgentTeamConfig):
+                description = node_def.role or node_def.description
+
+            prompt_parts.append(f"- name: {node.name}\n  description: {description}")
+
+        if not prompt_parts:
+            return "You are working alone. You have no team members to delegate to."
+
+        return "\n".join(prompt_parts)

autobyteus/agent_team/task_notification/task_notification_mode.py

@@ -2,6 +2,7 @@
 """
 Defines the enum for controlling how task notifications are handled in an agent team.
 """
+import os
 from enum import Enum
 
 class TaskNotificationMode(str, Enum):
@@ -22,3 +23,21 @@ class TaskNotificationMode(str, Enum):
 
     def __str__(self) -> str:
         return self.value
+
+
+ENV_TASK_NOTIFICATION_MODE = "AUTOBYTEUS_TASK_NOTIFICATION_MODE"
+DEFAULT_TASK_NOTIFICATION_MODE = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+_VALID_TASK_NOTIFICATION_MODES = {mode.value: mode for mode in TaskNotificationMode}
+
+
+def resolve_task_notification_mode() -> TaskNotificationMode:
+    """
+    Resolve task notification mode from environment.
+
+    Env var: AUTOBYTEUS_TASK_NOTIFICATION_MODE
+    """
+    raw_value = os.getenv(ENV_TASK_NOTIFICATION_MODE)
+    if not raw_value:
+        return DEFAULT_TASK_NOTIFICATION_MODE
+    normalized = raw_value.strip().lower()
+    return _VALID_TASK_NOTIFICATION_MODES.get(normalized, DEFAULT_TASK_NOTIFICATION_MODE)

autobyteus/agent_team/utils/wait_for_idle.py

@@ -4,7 +4,7 @@ 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
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 
 if TYPE_CHECKING:
     from autobyteus.agent_team.agent_team import AgentTeam
@@ -14,10 +14,10 @@ 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:
+        if event.event_source_type == "TEAM" and event.data.new_status == AgentTeamStatus.IDLE:
             logger.info(f"Team '{team_id}' has become idle.")
             return
-        if event.event_source_type == "TEAM" and event.data.new_phase == AgentTeamOperationalPhase.ERROR:
+        if event.event_source_type == "TEAM" and event.data.new_status == AgentTeamStatus.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)
@@ -34,7 +34,7 @@ async def wait_for_team_to_be_idle(team: 'AgentTeam', timeout: float = 60.0):
         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:
+    if team.get_current_status() == AgentTeamStatus.IDLE:
         return
     
     logger.info(f"Waiting for team '{team.team_id}' to become idle (timeout: {timeout}s)...")

autobyteus/cli/agent_cli.py

@@ -70,16 +70,24 @@ async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool
             agent_turn_complete_event.clear()
 
             if cli_display.pending_approval_data:
-                approval_input = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
-                approval_input = approval_input.strip().lower()
-                
-                approval_data = cli_display.pending_approval_data
-                cli_display.pending_approval_data = None
-                
-                is_approved = approval_input in ["y", "yes"]
-                reason = "User approved via CLI" if is_approved else "User denied via CLI"
-                
-                await agent.post_tool_execution_approval(approval_data.invocation_id, is_approved, reason)
+                approval_prompt = cli_display.get_approval_prompt()
+                if approval_prompt:
+                    approval_input = await asyncio.get_event_loop().run_in_executor(None, lambda: input(approval_prompt))
+                    approval_input = approval_input.strip().lower()
+                    
+                    approval_data = cli_display.pending_approval_data
+                    cli_display.clear_pending_approval()
+                    
+                    is_approved = approval_input in ["y", "yes"]
+                    reason = "User approved via CLI"
+                    
+                    if not is_approved:
+                        reason_input = await asyncio.get_event_loop().run_in_executor(None, lambda: input("Reason (optional): "))
+                        reason = reason_input.strip()
+                        if not reason:
+                            reason = "User denied via CLI"
+                    
+                    await agent.post_tool_execution_approval(approval_data.invocation_id, is_approved, reason)
 
             else:
                 sys.stdout.write("You: ")

autobyteus/cli/agent_team_tui/app.py

@@ -13,11 +13,12 @@ from textual.widgets import Header, Static
 from textual.reactive import reactive
 
 from autobyteus.agent_team.agent_team import AgentTeam
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 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 autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamStatusUpdateData
 
 from .state import TUIStateStore
 from .widgets.agent_list_sidebar import AgentListSidebar
@@ -104,7 +105,9 @@ class AgentTeamApp(App):
                 self._ui_update_pending = True
                 
                 # 3. Handle real-time, incremental updates directly.
-                if isinstance(event.data, AgentEventRebroadcastPayload):
+                if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamStatusUpdateData):
+                    self.store._team_statuses[self.team.name] = event.data.new_status
+                elif isinstance(event.data, AgentEventRebroadcastPayload):
                     payload = event.data
                     agent_name = payload.agent_name
                     agent_event = payload.agent_event
@@ -132,11 +135,11 @@ class AgentTeamApp(App):
         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
+        agent_statuses = self.store._agent_statuses
+        team_statuses = self.store._team_statuses
         speaking_agents = self.store._speaking_agents
         
-        sidebar.update_tree(tree_data, agent_phases, team_phases, speaking_agents)
+        sidebar.update_tree(tree_data, agent_statuses, team_statuses, speaking_agents)
         
         focused_data = self.focused_node_data
         if focused_data and focused_data.get("type") in ['team', 'subteam']:
@@ -147,13 +150,13 @@ class AgentTeamApp(App):
                 node_data=focused_data,
                 history=[], # No history for teams
                 pending_approval=None,
-                all_agent_phases=agent_phases,
-                all_team_phases=team_phases,
+                all_agent_statuses=agent_statuses,
+                all_team_statuses=team_statuses,
                 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)
+            focus_pane.update_current_node_status(agent_statuses, team_statuses)
 
 
     async def watch_focused_node_data(self, new_node_data: Optional[Dict[str, Any]]):
@@ -179,8 +182,8 @@ class AgentTeamApp(App):
             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,
+            all_agent_statuses=self.store._agent_statuses,
+            all_team_statuses=self.store._team_statuses,
             task_plan=task_plan,
             task_statuses=task_statuses
         )

autobyteus/cli/agent_team_tui/state.py

@@ -7,15 +7,15 @@ import copy
 
 from autobyteus.agent.context import AgentConfig
 from autobyteus.agent_team.agent_team import AgentTeam
-from autobyteus.agent.phases import AgentOperationalPhase
-from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
-    AgentOperationalPhaseTransitionData, ToolInvocationApprovalRequestedData, 
-    AssistantChunkData, AssistantCompleteResponseData
+    AgentStatusUpdateData, ToolInvocationApprovalRequestedData, 
+    AssistantCompleteResponseData
 )
 from autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
-from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamPhaseTransitionData
+from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamStatusUpdateData
 from autobyteus.task_management.task import Task
 from autobyteus.task_management.events import TasksCreatedEvent, TaskStatusUpdatedEvent
 from autobyteus.task_management.base_task_plan import TaskStatus
@@ -39,8 +39,8 @@ class TUIStateStore:
         
         self._node_roles: Dict[str, str] = self._extract_node_roles(team)
         self._nodes: Dict[str, Any] = self._initialize_root_node()
-        self._agent_phases: Dict[str, AgentOperationalPhase] = {}
-        self._team_phases: Dict[str, AgentTeamOperationalPhase] = {self.team_name: AgentTeamOperationalPhase.UNINITIALIZED}
+        self._agent_statuses: Dict[str, AgentStatus] = {}
+        self._team_statuses: Dict[str, AgentTeamStatus] = {self.team_name: AgentTeamStatus.UNINITIALIZED}
         self._agent_event_history: Dict[str, List[AgentStreamEvent]] = {}
         self._team_event_history: Dict[str, List[AgentTeamStreamEvent]] = {self.team_name: []}
         self._pending_approvals: Dict[str, ToolInvocationApprovalRequestedData] = {}
@@ -75,8 +75,8 @@ class TUIStateStore:
     def process_event(self, event: AgentTeamStreamEvent):
         self.version += 1 # Increment on any event to signal a change
         
-        if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamPhaseTransitionData):
-            self._team_phases[self.team_name] = event.data.new_phase
+        if event.event_source_type == "TEAM" and isinstance(event.data, AgentTeamStatusUpdateData):
+            self._team_statuses[self.team_name] = event.data.new_status
         
         self._process_event_recursively(event, self.team_name)
 
@@ -121,11 +121,9 @@ class TUIStateStore:
                 else: logger.error(f"Cannot add agent node '{agent_name}': parent '{parent_name}' not found.")
             self._agent_event_history[agent_name].append(agent_event)
 
-            if agent_event.event_type == AgentStreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION:
-                self._agent_phases[agent_name] = agent_event.data.new_phase
+            if agent_event.event_type == AgentStreamEventType.AGENT_STATUS_UPDATED:
+                self._agent_statuses[agent_name] = agent_event.data.new_status
                 if agent_name in self._pending_approvals: del self._pending_approvals[agent_name]
-            elif agent_event.event_type == AgentStreamEventType.AGENT_IDLE:
-                self._agent_phases[agent_name] = AgentOperationalPhase.IDLE
             elif agent_event.event_type == AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED:
                 self._pending_approvals[agent_name] = agent_event.data
 
@@ -136,8 +134,8 @@ class TUIStateStore:
             if not self._find_node(sub_team_name):
                 role = self._node_roles.get(sub_team_name, "Sub-Team")
                 self._add_node(sub_team_name, {"type": "subteam", "name": sub_team_name, "role": role, "children": {}}, parent_name)
-            if sub_team_event.event_source_type == "TEAM" and isinstance(sub_team_event.data, AgentTeamPhaseTransitionData):
-                self._team_phases[sub_team_name] = sub_team_event.data.new_phase
+            if sub_team_event.event_source_type == "TEAM" and isinstance(sub_team_event.data, AgentTeamStatusUpdateData):
+                self._team_statuses[sub_team_name] = sub_team_event.data.new_status
             self._process_event_recursively(sub_team_event, parent_name=sub_team_name)
 
     def _add_node(self, node_name: str, node_data: Dict, parent_name: str):

autobyteus/cli/agent_team_tui/widgets/agent_list_sidebar.py

@@ -10,10 +10,10 @@ from textual.widgets import Static, Tree
 from textual.widgets.tree import TreeNode
 from textual.containers import Vertical
 
-from autobyteus.agent.phases import AgentOperationalPhase
-from autobyteus.agent_team.phases import AgentTeamOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.agent_team.status.agent_team_status import AgentTeamStatus
 from .shared import (
-    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, 
+    AGENT_STATUS_ICONS, TEAM_STATUS_ICONS, SUB_TEAM_ICON,
     TEAM_ICON, SPEAKING_ICON, DEFAULT_ICON
 )
 from .logo import Logo
@@ -45,19 +45,19 @@ class AgentListSidebar(Static):
             self.post_message(self.NodeSelected(event.node.data))
         event.stop()
 
-    def _build_label(self, name: str, node_data: Dict, agent_phases: Dict, team_phases: Dict, speaking_agents: Dict) -> str:
+    def _build_label(self, name: str, node_data: Dict, agent_statuses: Dict, team_statuses: Dict, speaking_agents: Dict) -> str:
         """Constructs the display label for a tree node."""
         node_type = node_data["type"]
         icon = DEFAULT_ICON
         
         if node_type == "agent":
-            phase = agent_phases.get(name, AgentOperationalPhase.UNINITIALIZED)
-            icon = SPEAKING_ICON if speaking_agents.get(name) else AGENT_PHASE_ICONS.get(phase, DEFAULT_ICON)
+            status = agent_statuses.get(name, AgentStatus.UNINITIALIZED)
+            icon = SPEAKING_ICON if speaking_agents.get(name) else AGENT_STATUS_ICONS.get(status, DEFAULT_ICON)
             label = f"{icon} {name}"
         elif node_type in ["team", "subteam"]:
-            phase = team_phases.get(name, AgentTeamOperationalPhase.UNINITIALIZED)
+            status = team_statuses.get(name, AgentTeamStatus.UNINITIALIZED)
             default_icon = TEAM_ICON if node_type == "team" else SUB_TEAM_ICON
-            icon = TEAM_PHASE_ICONS.get(phase, default_icon)
+            icon = TEAM_STATUS_ICONS.get(status, default_icon)
             role = node_data.get("role")
             label = f"{icon} {role or name}"
             if role and role != name:
@@ -67,7 +67,7 @@ class AgentListSidebar(Static):
             
         return label
 
-    def update_tree(self, tree_data: Dict, agent_phases: Dict[str, AgentOperationalPhase], team_phases: Dict[str, AgentTeamOperationalPhase], speaking_agents: Dict[str, bool]):
+    def update_tree(self, tree_data: Dict, agent_statuses: Dict[str, AgentStatus], team_statuses: Dict[str, AgentTeamStatus], speaking_agents: Dict[str, bool]):
         """
         Performs an in-place update of the tree to reflect the new state,
         avoiding a full rebuild for better performance and preserving UI state like expansion.
@@ -82,17 +82,17 @@ class AgentListSidebar(Static):
         root_node_data = tree_data[root_name]
 
         # Kick off the recursive update from the root.
-        self._update_node_recursively(tree.root, root_node_data, agent_phases, team_phases, speaking_agents)
+        self._update_node_recursively(tree.root, root_node_data, agent_statuses, team_statuses, speaking_agents)
         
         # Ensure the root is expanded on the first run.
         if not tree.root.is_expanded:
             tree.root.expand()
 
-    def _update_node_recursively(self, ui_node: TreeNode, node_data: Dict, agent_phases: Dict, team_phases: Dict, speaking_agents: Dict):
+    def _update_node_recursively(self, ui_node: TreeNode, node_data: Dict, agent_statuses: Dict, team_statuses: Dict, speaking_agents: Dict):
         """Recursively updates a node and reconciles its children."""
         # 1. Update the current node's label and data
         name = node_data['name']
-        label = self._build_label(name, node_data, agent_phases, team_phases, speaking_agents)
+        label = self._build_label(name, node_data, agent_statuses, team_statuses, speaking_agents)
         ui_node.set_label(label)
         ui_node.data = node_data
         self._node_map[name] = ui_node  # Ensure map is always up-to-date
@@ -106,10 +106,10 @@ class AgentListSidebar(Static):
             if child_name in existing_ui_children_by_name:
                 # Node exists, so we recursively update it
                 child_ui_node = existing_ui_children_by_name[child_name]
-                self._update_node_recursively(child_ui_node, child_data, agent_phases, team_phases, speaking_agents)
+                self._update_node_recursively(child_ui_node, child_data, agent_statuses, team_statuses, speaking_agents)
             else:
                 # Node is new, so we add it
-                new_child_label = self._build_label(child_name, child_data, agent_phases, team_phases, speaking_agents)
+                new_child_label = self._build_label(child_name, child_data, agent_statuses, team_statuses, speaking_agents)
                 is_leaf = child_data.get("children", {}) == {} and child_data['type'] == 'agent'
                 
                 if is_leaf:
@@ -117,7 +117,7 @@ class AgentListSidebar(Static):
                 else:
                     new_ui_node = ui_node.add(new_child_label, data=child_data)
                     # Since this is a new branch, we must build its children too
-                    self._update_node_recursively(new_ui_node, child_data, agent_phases, team_phases, speaking_agents)
+                    self._update_node_recursively(new_ui_node, child_data, agent_statuses, team_statuses, speaking_agents)
                 
                 self._node_map[child_name] = new_ui_node