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

autobyteus/cli/workflow_tui/widgets/agent_list_sidebar.py

@@ -0,0 +1,149 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/agent_list_sidebar.py
+"""
+Defines the sidebar widget that lists all nodes in the workflow hierarchy.
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from textual.message import Message
+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.workflow.phases import WorkflowOperationalPhase
+from .shared import (
+    AGENT_PHASE_ICONS, WORKFLOW_PHASE_ICONS, SUB_WORKFLOW_ICON, 
+    WORKFLOW_ICON, SPEAKING_ICON, DEFAULT_ICON
+)
+from .logo import Logo
+
+logger = logging.getLogger(__name__)
+
+class AgentListSidebar(Static):
+    """A widget to display the hierarchical list of workflow nodes. This is a dumb
+    rendering component driven by the TUIStateStore."""
+
+    class NodeSelected(Message):
+        """Posted when any node is selected in the tree."""
+        def __init__(self, node_data: Dict[str, Any]) -> None:
+            self.node_data = node_data
+            super().__init__()
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._node_map: Dict[str, TreeNode] = {} # Maps node names to TreeNode objects
+
+    def compose(self):
+        with Vertical():
+            yield Tree("Workflow", id="agent-tree")
+            yield Logo()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        """Handle node selection from the tree."""
+        if event.node.data:
+            self.post_message(self.NodeSelected(event.node.data))
+        event.stop()
+
+    def _build_label(self, name: str, node_data: Dict, agent_phases: Dict, workflow_phases: 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)
+            label = f"{icon} {name}"
+        elif node_type in ["workflow", "subworkflow"]:
+            phase = workflow_phases.get(name, WorkflowOperationalPhase.UNINITIALIZED)
+            default_icon = WORKFLOW_ICON if node_type == "workflow" else SUB_WORKFLOW_ICON
+            icon = WORKFLOW_PHASE_ICONS.get(phase, default_icon)
+            role = node_data.get("role")
+            label = f"{icon} {role or name}"
+            if role and role != name:
+                label += f" ({name})"
+        else:
+            label = f"{icon} {name}"
+            
+        return label
+
+    def update_tree(self, tree_data: Dict, agent_phases: Dict[str, AgentOperationalPhase], workflow_phases: Dict[str, WorkflowOperationalPhase], 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.
+        """
+        tree = self.query_one(Tree)
+
+        if not tree_data:
+            tree.root.set_label("Initializing workflow...")
+            return
+
+        root_name = list(tree_data.keys())[0]
+        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, workflow_phases, 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, workflow_phases: 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, workflow_phases, 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
+
+        # 2. Reconcile children
+        new_children_data = node_data.get("children", {})
+        existing_ui_children_by_name = {child.data['name']: child for child in ui_node.children if child.data}
+
+        # Add new nodes and update existing ones
+        for child_name, child_data in new_children_data.items():
+            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, workflow_phases, speaking_agents)
+            else:
+                # Node is new, so we add it
+                new_child_label = self._build_label(child_name, child_data, agent_phases, workflow_phases, speaking_agents)
+                is_leaf = child_data.get("children", {}) == {} and child_data['type'] == 'agent'
+                
+                if is_leaf:
+                    new_ui_node = ui_node.add_leaf(new_child_label, data=child_data)
+                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, workflow_phases, speaking_agents)
+                
+                self._node_map[child_name] = new_ui_node
+
+        # Remove old nodes that no longer exist in the new data
+        nodes_to_remove = []
+        for existing_child_name, existing_child_node in existing_ui_children_by_name.items():
+            if existing_child_name not in new_children_data:
+                nodes_to_remove.append(existing_child_node)
+                if existing_child_name in self._node_map:
+                    del self._node_map[existing_child_name]
+        
+        for node in nodes_to_remove:
+            node.remove()
+
+    def update_selection(self, node_name: Optional[str]):
+        """Updates the tree's selection and expands parents to make it visible."""
+        if not node_name or node_name not in self._node_map:
+            return
+            
+        tree = self.query_one(Tree)
+        node_to_select = self._node_map[node_name]
+        
+        parent = node_to_select.parent
+        while parent:
+            parent.expand()
+            parent = parent.parent
+        
+        tree.select_node(node_to_select)
+        tree.scroll_to_node(node_to_select)

autobyteus/cli/workflow_tui/widgets/focus_pane.py

@@ -0,0 +1,335 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/focus_pane.py
+"""
+Defines the main focus pane widget for displaying detailed logs or summaries.
+"""
+import logging
+import json
+from typing import Optional, List, Any, Dict
+
+from rich.text import Text
+from rich.panel import Panel
+from rich.syntax import Syntax
+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.workflow.phases import WorkflowOperationalPhase
+from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
+from autobyteus.agent.streaming.stream_event_payloads import (
+    AgentOperationalPhaseTransitionData, AssistantChunkData, AssistantCompleteResponseData,
+    ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData
+)
+from .shared import (
+    AGENT_PHASE_ICONS, WORKFLOW_PHASE_ICONS, SUB_WORKFLOW_ICON, DEFAULT_ICON,
+    USER_ICON, ASSISTANT_ICON, WORKFLOW_ICON, AGENT_ICON
+)
+from . import renderables
+
+logger = logging.getLogger(__name__)
+
+class FocusPane(Static):
+    """
+    A widget to display detailed logs for agents or high-level dashboards for workflows.
+    This is a dumb rendering component driven by the TUIStateStore.
+    """
+
+    class MessageSubmitted(Message):
+        def __init__(self, text: str, agent_name: str) -> None:
+            self.text = text
+            self.agent_name = agent_name
+            super().__init__()
+
+    class ApprovalSubmitted(Message):
+        def __init__(self, agent_name: str, invocation_id: str, is_approved: bool, reason: Optional[str]) -> None:
+            self.agent_name = agent_name
+            self.invocation_id = invocation_id
+            self.is_approved = is_approved
+            self.reason = reason
+            super().__init__()
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._focused_node_data: Optional[Dict[str, Any]] = None
+        self._pending_approval_data: Optional[ToolInvocationApprovalRequestedData] = None
+        
+        # State variables for streaming
+        self._thinking_widget: Optional[Static] = None
+        self._thinking_text: Optional[Text] = None
+        self._assistant_content_widget: Optional[Static] = None
+        self._assistant_content_text: Optional[Text] = None
+        
+        # Buffers for batched UI updates to improve performance
+        self._reasoning_buffer: str = ""
+        self._content_buffer: str = ""
+
+    def compose(self):
+        yield Static("Select a node from the sidebar", id="focus-pane-title")
+        yield VerticalScroll(id="focus-pane-log-container")
+        yield Horizontal(id="approval-buttons")
+        yield Input(placeholder="Select an agent to send messages...", id="focus-pane-input", disabled=True)
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.value and self._focused_node_data and self._focused_node_data.get("type") == 'agent':
+            log_container = self.query_one("#focus-pane-log-container")
+            user_message_text = Text(f"{USER_ICON} You: {event.value}", style="bright_blue")
+            await log_container.mount(Static(""))
+            await log_container.mount(Static(user_message_text))
+            log_container.scroll_end(animate=False)
+            
+            self.post_message(self.MessageSubmitted(event.value, self._focused_node_data['name']))
+            self.query_one(Input).clear()
+        event.stop()
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if not self._pending_approval_data or not self._focused_node_data:
+            return
+
+        is_approved = event.button.id == "approve-btn"
+        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"
+        display_text = Text(f"{USER_ICON} You: {approval_text} (Reason: {reason})", style="bright_cyan")
+        await log_container.mount(Static(""))
+        await log_container.mount(Static(display_text))
+        log_container.scroll_end(animate=False)
+
+        self.post_message(self.ApprovalSubmitted(
+            agent_name=self._focused_node_data['name'],
+            invocation_id=self._pending_approval_data.invocation_id,
+            is_approved=is_approved, reason=reason
+        ))
+        await self._clear_approval_ui()
+        event.stop()
+
+    async def _clear_approval_ui(self):
+        self._pending_approval_data = None
+        await self.query_one("#approval-buttons").remove_children()
+        input_widget = self.query_one(Input)
+        if self._focused_node_data and self._focused_node_data.get("type") == "agent":
+            input_widget.disabled = False
+            input_widget.placeholder = f"Send a message to {self._focused_node_data['name']}..."
+            input_widget.focus()
+        else:
+            input_widget.disabled = True
+            input_widget.placeholder = "Select an agent to send messages..."
+
+    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
+        button_container = self.query_one("#approval-buttons")
+        await button_container.remove_children()
+        await button_container.mount(
+            Button("Approve", variant="success", id="approve-btn"),
+            Button("Deny", variant="error", id="deny-btn")
+        )
+
+    def _update_title(self, agent_phases: Dict[str, AgentOperationalPhase], workflow_phases: Dict[str, WorkflowOperationalPhase]):
+        """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")
+            return
+
+        node_name = self._focused_node_data.get("name", "Unknown")
+        node_type = self._focused_node_data.get("type", "node")
+        node_type_str = node_type.replace("_", " ").capitalize()
+
+        title_icon = DEFAULT_ICON
+        phase_str = ""
+
+        if node_type == 'agent':
+            title_icon = AGENT_ICON
+            phase = agent_phases.get(node_name, AgentOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+        elif node_type == 'subworkflow':
+            title_icon = SUB_WORKFLOW_ICON
+            phase = workflow_phases.get(node_name, WorkflowOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+        elif node_type == 'workflow':
+            title_icon = WORKFLOW_ICON
+            phase = workflow_phases.get(node_name, WorkflowOperationalPhase.UNINITIALIZED)
+            phase_str = f" (Status: {phase.value})"
+
+        self.query_one("#focus-pane-title").update(f"{title_icon} {node_type_str}: [bold]{node_name}[/bold]{phase_str}")
+        
+    def update_current_node_status(self, all_agent_phases: Dict, all_workflow_phases: Dict):
+        """A lightweight method to only update the title with the latest status."""
+        self._update_title(all_agent_phases, all_workflow_phases)
+
+    async def update_content(self, node_data: Dict[str, Any], history: List[Any], 
+                             pending_approval: Optional[ToolInvocationApprovalRequestedData], 
+                             all_agent_phases: Dict[str, AgentOperationalPhase], 
+                             all_workflow_phases: Dict[str, WorkflowOperationalPhase]):
+        """The main method to update the entire pane based on new state.
+        This is called when focus SWITCHES, or when data for a focused workflow is REFRESHED."""
+        self.flush_stream_buffers()
+
+        self._focused_node_data = node_data
+        self._pending_approval_data = pending_approval
+        
+        self._update_title(all_agent_phases, all_workflow_phases)
+
+        log_container = self.query_one("#focus-pane-log-container")
+        await log_container.remove_children()
+
+        # Reset streaming state
+        self._thinking_widget = None
+        self._thinking_text = None
+        self._assistant_content_widget = None
+        self._assistant_content_text = None
+
+        await self._clear_approval_ui()
+
+        if self._focused_node_data.get("type") == 'agent':
+            for event in history:
+                await self.add_agent_event(event)
+            if self._pending_approval_data:
+                await self._show_approval_prompt()
+        elif self._focused_node_data.get("type") in ['workflow', 'subworkflow']:
+            await self._render_workflow_dashboard(node_data, all_agent_phases, all_workflow_phases)
+
+    async def _render_workflow_dashboard(self, node_data: Dict[str, Any], 
+                                         all_agent_phases: Dict[str, AgentOperationalPhase],
+                                         all_workflow_phases: Dict[str, WorkflowOperationalPhase]):
+        """Renders a static summary dashboard for a workflow or sub-workflow."""
+        log_container = self.query_one("#focus-pane-log-container")
+        
+        phase = all_workflow_phases.get(node_data['name'], WorkflowOperationalPhase.UNINITIALIZED)
+        phase_icon = WORKFLOW_PHASE_ICONS.get(phase, 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}")
+        await log_container.mount(Static(Panel(info_text, title="Workflow Info", border_style="green", title_align="left")))
+
+        children_data = node_data.get("children", {})
+        if children_data:
+            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")
+                elif child_node['type'] == 'subworkflow':
+                    wf_phase = all_workflow_phases.get(name, WorkflowOperationalPhase.UNINITIALIZED)
+                    wf_icon = WORKFLOW_PHASE_ICONS.get(wf_phase, SUB_WORKFLOW_ICON)
+                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Workflow): {wf_phase.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):
+        """Finalizes and closes the current thinking block if it's open."""
+        if self._thinking_widget and self._thinking_text:
+            self.flush_stream_buffers() # Ensure any buffered reasoning is flushed first
+            self._thinking_text.append("\n</Thinking>", style="dim italic cyan")
+            self._thinking_widget.update(self._thinking_text)
+            if scroll:
+                self.query_one("#focus-pane-log-container").scroll_end(animate=False)
+            self._thinking_widget = None
+            self._thinking_text = None
+
+    def flush_stream_buffers(self):
+        """Flushes the content of the stream buffers to the UI."""
+        scrolled = False
+        if self._reasoning_buffer and self._thinking_widget and self._thinking_text:
+            self._thinking_text.append(self._reasoning_buffer)
+            self._thinking_widget.update(self._thinking_text)
+            self._reasoning_buffer = ""
+            scrolled = True
+
+        if self._content_buffer and self._assistant_content_widget and self._assistant_content_text:
+            self._assistant_content_text.append(self._content_buffer)
+            self._assistant_content_widget.update(self._assistant_content_text)
+            self._content_buffer = ""
+            scrolled = True
+        
+        if scrolled:
+            self.query_one("#focus-pane-log-container").scroll_end(animate=False)
+
+    async def add_agent_event(self, event: AgentStreamEvent):
+        """Adds a single agent event to the log view, handling stream state correctly."""
+        log_container = self.query_one("#focus-pane-log-container")
+        event_type = event.event_type
+
+        # Handle streaming content events
+        if event_type == AgentStreamEventType.ASSISTANT_CHUNK:
+            data: AssistantChunkData = event.data
+            if data.reasoning:
+                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)
+                self._reasoning_buffer += data.reasoning
+
+            if data.content:
+                if self._thinking_widget:
+                    await self._close_thinking_block()
+                if self._assistant_content_widget is None:
+                    await log_container.mount(Static(""))
+                    self._assistant_content_text = Text()
+                    self._assistant_content_text.append(f"{ASSISTANT_ICON} assistant: ", style="bold green")
+                    self._assistant_content_widget = Static(self._assistant_content_text)
+                    await log_container.mount(self._assistant_content_widget)
+                self._content_buffer += data.content
+            return  # This event is handled, do nothing more.
+
+        # Handle the explicit end of a stream
+        if event_type == AgentStreamEventType.ASSISTANT_COMPLETE_RESPONSE:
+            was_streaming_content = self._assistant_content_widget is not None
+            self.flush_stream_buffers()
+            await self._close_thinking_block()
+            self._assistant_content_widget = None
+            self._assistant_content_text = None
+
+            # If we weren't streaming, it means this is a non-streamed response. We should render it.
+            if 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)
+            return  # This event's purpose is to end the stream.
+
+        # For all other events, first check if they should break an ongoing stream.
+        is_stream_breaking_event = event_type in [
+            AgentStreamEventType.TOOL_INTERACTION_LOG_ENTRY,
+            AgentStreamEventType.TOOL_INVOCATION_AUTO_EXECUTING,
+            AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED,
+            AgentStreamEventType.ERROR_EVENT,
+        ]
+
+        if is_stream_breaking_event:
+            # Finalize any open assistant block before rendering this event.
+            self.flush_stream_buffers()
+            await self._close_thinking_block()
+            self._assistant_content_widget = None
+            self._assistant_content_text = None
+        
+        # Now, render the event if it has a visual representation.
+        renderable = None
+        
+        if event_type == AgentStreamEventType.TOOL_INTERACTION_LOG_ENTRY:
+            renderable = renderables.render_tool_interaction_log(event.data)
+        elif event_type == AgentStreamEventType.TOOL_INVOCATION_AUTO_EXECUTING:
+            renderable = renderables.render_tool_auto_executing(event.data)
+        elif event_type == AgentStreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED:
+            renderable = renderables.render_tool_approval_request(event.data)
+            self._pending_approval_data = event.data
+            await self._show_approval_prompt()
+        elif event_type == AgentStreamEventType.ERROR_EVENT:
+            renderable = renderables.render_error(event.data)
+        elif event_type in [AgentStreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION, AgentStreamEventType.AGENT_IDLE]:
+            # These are informational and do not have a renderable in the log pane.
+            pass
+
+        if renderable:
+            await log_container.mount(Static("")) # Add spacer
+            await log_container.mount(Static(renderable))
+
+        log_container.scroll_end(animate=False)

autobyteus/cli/workflow_tui/widgets/logo.py

@@ -0,0 +1,27 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/logo.py
+"""
+Defines a widget to display the AutoByteus ASCII art logo and tagline.
+"""
+from rich.text import Text
+from textual.widgets import Static
+from textual.containers import Vertical
+
+class Logo(Vertical):
+    """A widget to display the AutoByteus ASCII art logo and tagline."""
+
+    def compose(self) -> None:
+        logo_text = Text(
+            """
+    _         _           _     _
+   / \\  _   _| |_ ___  __| | __| |_
+  / _ \\| | | | __/ _ \\/ _` |/ _` | |
+ / ___ \\ |_| | ||  __/ (_| | (_| | |
+/_/   \\_\\__,_|\\__\\___|\\__,_|\\__,_|_|
+""",
+            justify="center",
+        )
+        logo_text.highlight_regex(r"Auto", "bold cyan")
+        logo_text.highlight_regex(r"Byteus", "bold magenta")
+        
+        yield Static(logo_text, classes="logo-art")
+        yield Static("Orchestrating AI Agent Teams.", classes="logo-tagline")

autobyteus/cli/workflow_tui/widgets/renderables.py

@@ -0,0 +1,70 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/renderables.py
+"""
+Contains pure functions that convert agent event data into Rich renderables for the FocusPane.
+This separates presentation logic from the view logic of the widget itself.
+"""
+import json
+from typing import Optional
+
+from rich.text import Text
+from rich.panel import Panel
+
+from autobyteus.agent.streaming.stream_event_payloads import (
+    AgentOperationalPhaseTransitionData, AssistantCompleteResponseData,
+    ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData
+)
+from .shared import ASSISTANT_ICON, TOOL_ICON, PROMPT_ICON, ERROR_ICON, LOG_ICON
+
+def render_assistant_complete_response(data: AssistantCompleteResponseData) -> list[Text | Panel]:
+    """Renders a complete, pre-aggregated assistant response."""
+    renderables = []
+    if data.reasoning:
+        reasoning_text = Text("<Thinking>\n", style="dim italic cyan")
+        reasoning_text.append(data.reasoning)
+        reasoning_text.append("\n</Thinking>", style="dim italic cyan")
+        renderables.append(reasoning_text)
+    
+    if data.content:
+        content_text = Text()
+        content_text.append(f"{ASSISTANT_ICON} assistant: ", style="bold green")
+        content_text.append(data.content)
+        renderables.append(content_text)
+    
+    return renderables
+
+def render_tool_interaction_log(data: ToolInteractionLogEntryData) -> Text:
+    """Renders a tool interaction log entry."""
+    return Text(f"{LOG_ICON} [tool-log] {data.log_entry}", style="dim")
+
+def render_tool_auto_executing(data: ToolInvocationAutoExecutingData) -> Text:
+    """Renders a notification that a tool is being executed automatically."""
+    try:
+        args_str = json.dumps(data.arguments, indent=2)
+    except (TypeError, OverflowError):
+        args_str = str(data.arguments)
+        
+    text_content = Text(f"{TOOL_ICON} Executing tool '", style="default")
+    text_content.append(f"{data.tool_name}", style="bold yellow")
+    text_content.append("' with arguments:\n", style="default")
+    text_content.append(args_str, style="yellow")
+    return text_content
+    
+def render_tool_approval_request(data: ToolInvocationApprovalRequestedData) -> Text:
+    """Renders a prompt for the user to approve a tool call."""
+    try:
+        args_str = json.dumps(data.arguments, indent=2)
+    except (TypeError, OverflowError):
+        args_str = str(data.arguments)
+
+    text_content = Text(f"{PROMPT_ICON} Requesting approval for tool '", style="default")
+    text_content.append(f"{data.tool_name}", style="bold yellow")
+    text_content.append("' with arguments:\n", style="default")
+    text_content.append(args_str, style="yellow")
+    return text_content
+
+def render_error(data: ErrorEventData) -> Text:
+    """Renders an error event."""
+    error_text = f"Error from {data.source}: {data.message}"
+    if data.details: 
+        error_text += f"\nDetails: {data.details}"
+    return Text(f"{ERROR_ICON} {error_text}", style="bold red")

autobyteus/cli/workflow_tui/widgets/shared.py

@@ -0,0 +1,51 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/shared.py
+"""
+Shared constants and data for TUI widgets.
+"""
+from typing import Dict
+from autobyteus.agent.phases import AgentOperationalPhase
+from autobyteus.workflow.phases import WorkflowOperationalPhase
+
+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: "❗",
+}
+
+WORKFLOW_PHASE_ICONS: Dict[WorkflowOperationalPhase, str] = {
+    WorkflowOperationalPhase.UNINITIALIZED: "⚪",
+    WorkflowOperationalPhase.BOOTSTRAPPING: "⏳",
+    WorkflowOperationalPhase.IDLE: "🟢",
+    WorkflowOperationalPhase.PROCESSING: "⚙️",
+    WorkflowOperationalPhase.SHUTTING_DOWN: "🌙",
+    WorkflowOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
+    WorkflowOperationalPhase.ERROR: "❗",
+}
+
+# Main component icons
+SUB_WORKFLOW_ICON = "📂"
+WORKFLOW_ICON = "🏁"
+AGENT_ICON = "🤖"
+
+# General UI icons
+SPEAKING_ICON = "🔊"
+DEFAULT_ICON = "❓"
+
+# Semantic icons for log entries
+USER_ICON = "👤"
+ASSISTANT_ICON = "🤖"
+TOOL_ICON = "🛠️"
+PROMPT_ICON = "❓"
+ERROR_ICON = "💥"
+PHASE_ICON = "🔄"
+LOG_ICON = "📄"

autobyteus/cli/workflow_tui/widgets/status_bar.py

@@ -0,0 +1,14 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/status_bar.py
+"""
+Defines the status bar widget for the TUI.
+"""
+
+from textual.widgets import Footer
+
+class StatusBar(Footer):
+    """A simple footer widget that displays key bindings."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        # This will be automatically populated by Textual's binding system.
+        # You can add more status information here if needed in the future.

autobyteus/events/event_types.py

@@ -42,5 +42,8 @@ class EventType(Enum):
     # --- Agent Errors (not necessarily phase changes, e.g., error during output generation) ---
     AGENT_ERROR_OUTPUT_GENERATION = "agent_error_output_generation"
 
+    # --- Workflow Events ---
+    WORKFLOW_STREAM_EVENT = "workflow_stream_event" # For unified workflow event stream
+
     def __str__(self): 
         return self.value