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

autobyteus/cli/agent_team_tui/widgets/focus_pane.py

@@ -12,18 +12,19 @@ from textual.message import Message
 from textual.widgets import Input, Static, Button
 from textual.containers import VerticalScroll, Horizontal
 
-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.task_management.base_task_plan import TaskStatus
 from autobyteus.task_management.task import Task
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
-    AgentOperationalPhaseTransitionData, AssistantChunkData, AssistantCompleteResponseData,
+    AgentStatusUpdateData, AssistantChunkData, AssistantCompleteResponseData,
     ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData,
-    SystemTaskNotificationData
+    SystemTaskNotificationData, SegmentEventData
 )
+from autobyteus.agent.streaming.parser.events import SegmentEventType, SegmentType
 from .shared import (
-    AGENT_PHASE_ICONS, TEAM_PHASE_ICONS, SUB_TEAM_ICON, DEFAULT_ICON,
+    AGENT_STATUS_ICONS, TEAM_STATUS_ICONS, SUB_TEAM_ICON, DEFAULT_ICON,
     USER_ICON, ASSISTANT_ICON, TEAM_ICON, AGENT_ICON, SYSTEM_TASK_ICON
 )
 from . import renderables
@@ -65,6 +66,8 @@ class FocusPane(Static):
         # Buffers for batched UI updates to improve performance
         self._reasoning_buffer: str = ""
         self._content_buffer: str = ""
+        self._segment_types_by_id: Dict[str, SegmentType] = {}
+        self._saw_segment_event: bool = False
 
     def compose(self):
         yield Static("Select a node from the sidebar", id="focus-pane-title")
@@ -89,7 +92,15 @@ class FocusPane(Static):
             return
 
         is_approved = event.button.id == "approve-btn"
-        reason = "User approved via TUI." if is_approved else "User denied via TUI."
+        
+        info_input = self.query_one(Input)
+        user_reason = info_input.value.strip()
+        info_input.value = "" # Clear the input
+        
+        if user_reason:
+            reason = user_reason
+        else:
+            reason = "User approved via TUI." if is_approved else "User denied via TUI."
         
         log_container = self.query_one("#focus-pane-log-container")
         approval_text = "APPROVED" if is_approved else "DENIED"
@@ -121,8 +132,8 @@ class FocusPane(Static):
     async def _show_approval_prompt(self):
         if not self._pending_approval_data: return
         input_widget = self.query_one(Input)
-        input_widget.placeholder = "Please approve or deny the tool call..."
-        input_widget.disabled = True
+        input_widget.placeholder = "Optional: Enter a reason for your decision..."
+        input_widget.disabled = False
         button_container = self.query_one("#approval-buttons")
         await button_container.remove_children()
         await button_container.mount(
@@ -130,7 +141,7 @@ class FocusPane(Static):
             Button("Deny", variant="error", id="deny-btn")
         )
 
-    def _update_title(self, agent_phases: Dict[str, AgentOperationalPhase], team_phases: Dict[str, AgentTeamOperationalPhase]):
+    def _update_title(self, agent_statuses: Dict[str, AgentStatus], team_statuses: Dict[str, AgentTeamStatus]):
         """Renders the title of the focus pane with the node's current status."""
         if not self._focused_node_data:
             self.query_one("#focus-pane-title").update("Select a node from the sidebar")
@@ -141,31 +152,31 @@ class FocusPane(Static):
         node_type_str = node_type.replace("_", " ").capitalize()
 
         title_icon = DEFAULT_ICON
-        phase_str = ""
+        status_str = ""
 
         if node_type == 'agent':
             title_icon = AGENT_ICON
-            phase = agent_phases.get(node_name, AgentOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = agent_statuses.get(node_name, AgentStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
         elif node_type == 'subteam':
             title_icon = SUB_TEAM_ICON
-            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = team_statuses.get(node_name, AgentTeamStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
         elif node_type == 'team':
             title_icon = TEAM_ICON
-            phase = team_phases.get(node_name, AgentTeamOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = team_statuses.get(node_name, AgentTeamStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
 
-        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{phase_str}")
+        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{status_str}")
         
-    def update_current_node_status(self, all_agent_phases: Dict, all_team_phases: Dict):
+    def update_current_node_status(self, all_agent_statuses: Dict, all_team_statuses: Dict):
         """A lightweight method to only update the title with the latest status."""
-        self._update_title(all_agent_phases, all_team_phases)
+        self._update_title(all_agent_statuses, all_team_statuses)
 
     async def update_content(self, node_data: Dict[str, Any], history: List[Any], 
                              pending_approval: Optional[ToolInvocationApprovalRequestedData], 
-                             all_agent_phases: Dict[str, AgentOperationalPhase], 
-                             all_team_phases: Dict[str, AgentTeamOperationalPhase],
+                             all_agent_statuses: Dict[str, AgentStatus],
+                             all_team_statuses: Dict[str, AgentTeamStatus],
                              task_plan: Optional[List[Task]],
                              task_statuses: Optional[Dict[str, TaskStatus]]):
         """The main method to update the entire pane based on new state."""
@@ -174,7 +185,7 @@ class FocusPane(Static):
         self._focused_node_data = node_data
         self._pending_approval_data = pending_approval
         
-        self._update_title(all_agent_phases, all_team_phases)
+        self._update_title(all_agent_statuses, all_team_statuses)
 
         log_container = self.query_one("#focus-pane-log-container")
         await log_container.remove_children()
@@ -192,23 +203,23 @@ class FocusPane(Static):
             if self._pending_approval_data:
                 await self._show_approval_prompt()
         elif self._focused_node_data.get("type") in ['team', 'subteam']:
-            await self._render_team_dashboard(node_data, all_agent_phases, all_team_phases, task_plan, task_statuses)
+            await self._render_team_dashboard(node_data, all_agent_statuses, all_team_statuses, task_plan, task_statuses)
 
-    async def _render_team_dashboard(self, node_data: Dict[str, Any], 
-                                         all_agent_phases: Dict[str, AgentOperationalPhase],
-                                         all_team_phases: Dict[str, AgentTeamOperationalPhase],
+    async def _render_team_dashboard(self, node_data: Dict[str, Any],
+                                         all_agent_statuses: Dict[str, AgentStatus],
+                                         all_team_statuses: Dict[str, AgentTeamStatus],
                                          task_plan: Optional[List[Task]],
                                          task_statuses: Optional[Dict[str, TaskStatus]]):
         """Renders a static summary dashboard for a team or sub-team."""
         log_container = self.query_one("#focus-pane-log-container")
         
-        phase = all_team_phases.get(node_data['name'], AgentTeamOperationalPhase.UNINITIALIZED)
-        phase_icon = TEAM_PHASE_ICONS.get(phase, DEFAULT_ICON)
+        status = all_team_statuses.get(node_data['name'], AgentTeamStatus.UNINITIALIZED)
+        status_icon = TEAM_STATUS_ICONS.get(status, DEFAULT_ICON)
         info_text = Text()
         info_text.append(f"Name: {node_data['name']}\n", style="bold")
         if node_data.get('role'):
             info_text.append(f"Role: {node_data['role']}\n")
-        info_text.append(f"Status: {phase_icon} {phase.value}")
+        info_text.append(f"Status: {status_icon} {status.value}")
         await log_container.mount(Static(Panel(info_text, title="Team Info", border_style="green", title_align="left")))
 
         await log_container.mount(TaskPlanPanel(tasks=task_plan, statuses=task_statuses, team_name=node_data['name']))
@@ -218,13 +229,13 @@ class FocusPane(Static):
             team_text = Text()
             for name, child_node in children_data.items():
                 if child_node['type'] == 'agent':
-                    agent_phase = all_agent_phases.get(name, AgentOperationalPhase.UNINITIALIZED)
-                    agent_icon = AGENT_PHASE_ICONS.get(agent_phase, DEFAULT_ICON)
-                    team_text.append(f" ▪ {agent_icon} {name} (Agent): {agent_phase.value}\n")
+                    agent_status = all_agent_statuses.get(name, AgentStatus.UNINITIALIZED)
+                    agent_icon = AGENT_STATUS_ICONS.get(agent_status, DEFAULT_ICON)
+                    team_text.append(f" ▪ {agent_icon} {name} (Agent): {agent_status.value}\n")
                 elif child_node['type'] == 'subteam':
-                    wf_phase = all_team_phases.get(name, AgentTeamOperationalPhase.UNINITIALIZED)
-                    wf_icon = TEAM_PHASE_ICONS.get(wf_phase, SUB_TEAM_ICON)
-                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Team): {wf_phase.value}\n")
+                    wf_status = all_team_statuses.get(name, AgentTeamStatus.UNINITIALIZED)
+                    wf_icon = TEAM_STATUS_ICONS.get(wf_status, SUB_TEAM_ICON)
+                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Team): {wf_status.value}\n")
             await log_container.mount(Static(Panel(team_text, title="Team Status", border_style="blue", title_align="left")))
 
     async def _close_thinking_block(self, scroll: bool = True):
@@ -252,10 +263,105 @@ class FocusPane(Static):
         if scrolled:
             self.query_one("#focus-pane-log-container").scroll_end(animate=False)
 
+    async def _ensure_thinking_widget(self, log_container: VerticalScroll) -> None:
+        if self._thinking_widget is None:
+            self.flush_stream_buffers()
+            await log_container.mount(Static(""))
+            self._thinking_text = Text("<Thinking>\n", style="dim italic cyan")
+            self._thinking_widget = Static(self._thinking_text)
+            await log_container.mount(self._thinking_widget)
+
+    async def _ensure_assistant_content_widget(self, log_container: VerticalScroll) -> None:
+        if self._assistant_content_widget is None:
+            await log_container.mount(Static(""))
+            self._assistant_content_text = Text(f"{ASSISTANT_ICON} assistant: ", style="bold green")
+            self._assistant_content_widget = Static(self._assistant_content_text)
+            await log_container.mount(self._assistant_content_widget)
+
+    async def _handle_segment_event(self, data: SegmentEventData) -> None:
+        log_container = self.query_one("#focus-pane-log-container")
+        self._saw_segment_event = True
+        try:
+            event_type = SegmentEventType(data.event_type)
+        except ValueError:
+            logger.debug(f"TUI FocusPane: Unknown segment event type '{data.event_type}'.")
+            return
+
+        segment_type = None
+        if data.segment_type:
+            try:
+                segment_type = SegmentType(data.segment_type)
+            except ValueError:
+                logger.debug(f"TUI FocusPane: Unknown segment type '{data.segment_type}'.")
+
+        if segment_type is None and data.segment_id in self._segment_types_by_id:
+            segment_type = self._segment_types_by_id.get(data.segment_id)
+
+        metadata = {}
+        if isinstance(data.payload, dict):
+            metadata = data.payload.get("metadata", {}) or {}
+
+        if event_type == SegmentEventType.START:
+            if segment_type is not None:
+                self._segment_types_by_id[data.segment_id] = segment_type
+
+            if segment_type != SegmentType.REASONING:
+                await self._close_thinking_block(scroll=False)
+
+            if segment_type == SegmentType.REASONING:
+                await self._ensure_thinking_widget(log_container)
+                return
+
+            await self._ensure_assistant_content_widget(log_container)
+
+            if segment_type == SegmentType.WRITE_FILE:
+                path = metadata.get("path", "")
+                header = f"<write_file path=\"{path}\">" if path else "<write_file>"
+                self._content_buffer += f"{header}\n"
+            elif segment_type == SegmentType.RUN_BASH:
+                self._content_buffer += "<run_bash>\n"
+            elif segment_type == SegmentType.TOOL_CALL:
+                tool_name = metadata.get("tool_name", "")
+                header = f"<tool name=\"{tool_name}\">" if tool_name else "<tool>"
+                self._content_buffer += f"{header}\n"
+            return
+
+        if event_type == SegmentEventType.CONTENT:
+            delta = ""
+            if isinstance(data.payload, dict):
+                delta = data.payload.get("delta", "")
+
+            if segment_type == SegmentType.REASONING:
+                await self._ensure_thinking_widget(log_container)
+                self._reasoning_buffer += str(delta)
+            else:
+                await self._ensure_assistant_content_widget(log_container)
+                self._content_buffer += str(delta)
+            return
+
+        if event_type == SegmentEventType.END:
+            if segment_type == SegmentType.REASONING:
+                await self._close_thinking_block()
+                self._segment_types_by_id.pop(data.segment_id, None)
+                return
+
+            if segment_type in {SegmentType.WRITE_FILE, SegmentType.RUN_BASH, SegmentType.TOOL_CALL}:
+                tag = "write_file" if segment_type == SegmentType.WRITE_FILE else (
+                    "run_bash" if segment_type == SegmentType.RUN_BASH else "tool"
+                )
+                self._content_buffer += f"\n</{tag}>\n"
+
+            self._segment_types_by_id.pop(data.segment_id, None)
+            return
+
     async def add_agent_event(self, event: AgentStreamEvent):
         log_container = self.query_one("#focus-pane-log-container")
         event_type = event.event_type
 
+        if event_type == AgentStreamEventType.SEGMENT_EVENT and isinstance(event.data, SegmentEventData):
+            await self._handle_segment_event(event.data)
+            return
+
         if event_type == AgentStreamEventType.ASSISTANT_CHUNK:
             data: AssistantChunkData = event.data
             if data.reasoning:
@@ -282,12 +388,13 @@ class FocusPane(Static):
             await self._close_thinking_block()
             self._assistant_content_widget = None
             self._assistant_content_text = None
-            if not was_streaming_content:
+            if not self._saw_segment_event and not was_streaming_content:
                 renderables_list = renderables.render_assistant_complete_response(event.data)
                 if renderables_list:
                     await log_container.mount(Static(""))
                     for item in renderables_list: await log_container.mount(Static(item))
                     log_container.scroll_end(animate=False)
+            self._saw_segment_event = False
             return
 
         is_stream_breaking_event = event_type in [

autobyteus/cli/agent_team_tui/widgets/renderables.py

@@ -10,7 +10,7 @@ from rich.text import Text
 from rich.panel import Panel
 
 from autobyteus.agent.streaming.stream_event_payloads import (
-    AgentOperationalPhaseTransitionData, AssistantCompleteResponseData,
+    AgentStatusUpdateData, AssistantCompleteResponseData,
     ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData,
     ToolInvocationAutoExecutingData, SystemTaskNotificationData
 )

autobyteus/cli/agent_team_tui/widgets/shared.py

@@ -2,34 +2,34 @@
 Shared constants and data for TUI widgets.
 """
 from typing import Dict
-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.task_management.base_task_plan import TaskStatus
 
-AGENT_PHASE_ICONS: Dict[AgentOperationalPhase, str] = {
-    AgentOperationalPhase.UNINITIALIZED: "⚪",
-    AgentOperationalPhase.BOOTSTRAPPING: "⏳",
-    AgentOperationalPhase.IDLE: "🟢",
-    AgentOperationalPhase.PROCESSING_USER_INPUT: "💭",
-    AgentOperationalPhase.AWAITING_LLM_RESPONSE: "💭",
-    AgentOperationalPhase.ANALYZING_LLM_RESPONSE: "🤔",
-    AgentOperationalPhase.AWAITING_TOOL_APPROVAL: "❓",
-    AgentOperationalPhase.TOOL_DENIED: "❌",
-    AgentOperationalPhase.EXECUTING_TOOL: "🛠️",
-    AgentOperationalPhase.PROCESSING_TOOL_RESULT: "⚙️",
-    AgentOperationalPhase.SHUTTING_DOWN: "🌙",
-    AgentOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
-    AgentOperationalPhase.ERROR: "❗",
+AGENT_STATUS_ICONS: Dict[AgentStatus, str] = {
+    AgentStatus.UNINITIALIZED: "⚪",
+    AgentStatus.BOOTSTRAPPING: "⏳",
+    AgentStatus.IDLE: "🟢",
+    AgentStatus.PROCESSING_USER_INPUT: "💭",
+    AgentStatus.AWAITING_LLM_RESPONSE: "💭",
+    AgentStatus.ANALYZING_LLM_RESPONSE: "🤔",
+    AgentStatus.AWAITING_TOOL_APPROVAL: "❓",
+    AgentStatus.TOOL_DENIED: "❌",
+    AgentStatus.EXECUTING_TOOL: "🛠️",
+    AgentStatus.PROCESSING_TOOL_RESULT: "⚙️",
+    AgentStatus.SHUTTING_DOWN: "🌙",
+    AgentStatus.SHUTDOWN_COMPLETE: "⚫",
+    AgentStatus.ERROR: "❗",
 }
 
-TEAM_PHASE_ICONS: Dict[AgentTeamOperationalPhase, str] = {
-    AgentTeamOperationalPhase.UNINITIALIZED: "⚪",
-    AgentTeamOperationalPhase.BOOTSTRAPPING: "⏳",
-    AgentTeamOperationalPhase.IDLE: "🟢",
-    AgentTeamOperationalPhase.PROCESSING: "⚙️",
-    AgentTeamOperationalPhase.SHUTTING_DOWN: "🌙",
-    AgentTeamOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
-    AgentTeamOperationalPhase.ERROR: "❗",
+TEAM_STATUS_ICONS: Dict[AgentTeamStatus, str] = {
+    AgentTeamStatus.UNINITIALIZED: "⚪",
+    AgentTeamStatus.BOOTSTRAPPING: "⏳",
+    AgentTeamStatus.IDLE: "🟢",
+    AgentTeamStatus.PROCESSING: "⚙️",
+    AgentTeamStatus.SHUTTING_DOWN: "🌙",
+    AgentTeamStatus.SHUTDOWN_COMPLETE: "⚫",
+    AgentTeamStatus.ERROR: "❗",
 }
 
 TASK_STATUS_ICONS: Dict[TaskStatus, str] = {
@@ -55,6 +55,6 @@ ASSISTANT_ICON = "🤖"
 TOOL_ICON = "🛠️"
 PROMPT_ICON = "❓"
 ERROR_ICON = "💥"
-PHASE_ICON = "🔄"
+STATUS_ICON = "🔄"
 LOG_ICON = "📄"
 SYSTEM_TASK_ICON = "📥" # NEW