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

autobyteus/agent/tool_execution_result_processor/processor_definition.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_definition.py
+import logging
+from typing import Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base_processor import BaseToolExecutionResultProcessor
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorDefinition:
+    """
+    Represents the definition of a tool execution result processor.
+    Contains its registered name and the class itself.
+    """
+    def __init__(self, name: str, processor_class: Type['BaseToolExecutionResultProcessor']):
+        """
+        Initializes the ToolExecutionResultProcessorDefinition.
+
+        Args:
+            name: The unique registered name of the processor.
+            processor_class: The class of the tool execution result processor.
+
+        Raises:
+            ValueError: If name is empty or processor_class is not a type.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Tool Execution Result Processor name must be a non-empty string.")
+        if not isinstance(processor_class, type):
+            raise ValueError("processor_class must be a class type.")
+        
+        self.name: str = name
+        self.processor_class: Type['BaseToolExecutionResultProcessor'] = processor_class
+        logger.debug(f"ToolExecutionResultProcessorDefinition created: name='{name}', class='{processor_class.__name__}'.")
+
+    def __repr__(self) -> str:
+        return f"<ToolExecutionResultProcessorDefinition name='{self.name}', class='{self.processor_class.__name__}'>"

autobyteus/agent/tool_execution_result_processor/processor_meta.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_meta.py
+import logging
+from abc import ABCMeta
+
+from .processor_registry import default_tool_execution_result_processor_registry
+from .processor_definition import ToolExecutionResultProcessorDefinition
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorMeta(ABCMeta):
+    """
+    Metaclass for BaseToolExecutionResultProcessor that automatically registers
+    concrete processor subclasses with the default registry.
+    """
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+
+        if name == 'BaseToolExecutionResultProcessor' or getattr(cls, "__abstractmethods__", None):
+            logger.debug(f"Skipping registration for abstract tool execution result processor class: {name}")
+            return
+
+        try:
+            processor_name = cls.get_name()
+
+            if not processor_name or not isinstance(processor_name, str):
+                logger.error(f"Tool execution result processor class {name} must return a valid string from get_name(). Skipping.")
+                return
+            
+            definition = ToolExecutionResultProcessorDefinition(name=processor_name, processor_class=cls)
+            default_tool_execution_result_processor_registry.register_processor(definition)
+            logger.info(f"Auto-registered tool execution result processor: '{processor_name}' from class {name}.")
+
+        except AttributeError as e:
+            logger.error(f"Tool execution result processor class {name} is missing 'get_name' method ({e}). Skipping registration.")
+        except Exception as e:
+            logger.error(f"Failed to auto-register tool execution result processor class {name}: {e}", exc_info=True)

autobyteus/agent/tool_execution_result_processor/processor_registry.py

@@ -0,0 +1,70 @@
+# file: autobyteus/autobyteus/agent/tool_execution_result_processor/processor_registry.py
+import logging
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from autobyteus.utils.singleton import SingletonMeta
+from .processor_definition import ToolExecutionResultProcessorDefinition
+
+if TYPE_CHECKING:
+    from .base_processor import BaseToolExecutionResultProcessor
+
+logger = logging.getLogger(__name__)
+
+class ToolExecutionResultProcessorRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for ToolExecutionResultProcessorDefinition objects.
+    Processors are typically auto-registered via ToolExecutionResultProcessorMeta.
+    """
+
+    def __init__(self):
+        """Initializes the registry with an empty store."""
+        self._definitions: Dict[str, ToolExecutionResultProcessorDefinition] = {}
+        logger.info("ToolExecutionResultProcessorRegistry initialized.")
+
+    def register_processor(self, definition: ToolExecutionResultProcessorDefinition) -> None:
+        """
+        Registers a tool execution result processor definition.
+        """
+        if not isinstance(definition, ToolExecutionResultProcessorDefinition):
+            raise TypeError(f"Expected ToolExecutionResultProcessorDefinition instance, got {type(definition).__name__}.")
+
+        processor_name = definition.name
+        if processor_name in self._definitions:
+            logger.warning(f"Overwriting existing tool execution result processor definition for name: '{processor_name}'.")
+        
+        self._definitions[processor_name] = definition
+        logger.info(f"Tool execution result processor definition '{processor_name}' registered successfully.")
+
+    def get_processor_definition(self, name: str) -> Optional[ToolExecutionResultProcessorDefinition]:
+        """
+        Retrieves a processor definition by its name.
+        """
+        return self._definitions.get(name)
+
+    def get_processor(self, name: str) -> Optional['BaseToolExecutionResultProcessor']:
+        """
+        Retrieves an instance of a processor by its name.
+        """
+        definition = self.get_processor_definition(name)
+        if definition:
+            try:
+                return definition.processor_class()
+            except Exception as e:
+                logger.error(f"Failed to instantiate tool execution result processor '{name}': {e}", exc_info=True)
+                return None
+        return None
+
+    def list_processor_names(self) -> List[str]:
+        """
+        Returns a list of names of all registered processor definitions.
+        """
+        return list(self._definitions.keys())
+
+    def get_all_definitions(self) -> Dict[str, ToolExecutionResultProcessorDefinition]:
+        """
+        Returns a dictionary of all registered processor definitions.
+        """
+        return dict(self._definitions)
+
+# Default instance of the registry
+default_tool_execution_result_processor_registry = ToolExecutionResultProcessorRegistry()

autobyteus/agent/workspace/base_workspace.py

@@ -1,5 +1,6 @@
 # file: autobyteus/autobyteus/agent/workspace/base_workspace.py
 import logging
+import uuid
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Dict, TYPE_CHECKING
 from autobyteus.tools.parameter_schema import ParameterSchema
@@ -29,7 +30,8 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         """
         self._config: WorkspaceConfig = config or WorkspaceConfig()
         self.context: Optional['AgentContext'] = None
-        logger.debug(f"{self.__class__.__name__} instance initialized. Context pending injection.")
+        self.workspace_id: str = str(uuid.uuid4())
+        logger.debug(f"{self.__class__.__name__} instance initialized with ID {self.workspace_id}. Context pending injection.")
 
     def set_context(self, context: 'AgentContext'):
         """
@@ -53,6 +55,19 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         """Configuration for the workspace. Implementations can use this as needed."""
         return self._config
 
+    @abstractmethod
+    def get_base_path(self) -> str:
+        """Returns the base path for the workspace, which can be used to resolve relative paths."""
+        pass
+    
+    def get_name(self) -> str:
+        """
+        Returns a user-friendly name for this workspace instance.
+        By default, it returns the unique workspace ID.
+        Subclasses can override this to provide a more descriptive name (e.g., a directory name).
+        """
+        return self.workspace_id
+
     # --- Methods for self-description ---
 
     @classmethod
@@ -74,4 +89,4 @@ class BaseAgentWorkspace(ABC, metaclass=WorkspaceMeta):
         pass
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} agent_id='{self.agent_id or 'N/A'}>"
+        return f"<{self.__class__.__name__} workspace_id='{self.workspace_id}' agent_id='{self.agent_id or 'N/A'}>"

autobyteus/cli/__init__.py

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

autobyteus/cli/cli_display.py

@@ -4,7 +4,7 @@ import sys
 from typing import Optional, List, Dict, Any
 import json 
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases.phase_enum import AgentOperationalPhase
 from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
     AssistantChunkData,

autobyteus/cli/workflow_tui/__init__.py

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

autobyteus/cli/workflow_tui/app.py

@@ -0,0 +1,210 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/app.py
+"""
+The main Textual application class for the workflow 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.workflow.agentic_workflow import AgenticWorkflow
+from autobyteus.workflow.streaming.workflow_event_stream import WorkflowEventStream
+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.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, WorkflowPhaseTransitionData
+
+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 WorkflowApp(App):
+    """A Textual TUI for interacting with an agentic workflow, 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, workflow: AgenticWorkflow, **kwargs):
+        super().__init__(**kwargs)
+        self.workflow = workflow
+        self.store = TUIStateStore(workflow=self.workflow)
+        self.workflow_stream: Optional[WorkflowEventStream] = 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.workflow.start()
+        self.workflow_stream = WorkflowEventStream(self.workflow)
+        
+        # Initialize the UI with the starting state
+        initial_tree = self.store.get_tree_data()
+        initial_focus_node = initial_tree.get(self.workflow.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_workflow_events(), name="workflow_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("Workflow TUI mounted, workflow listener and throttled UI updater started.")
+
+    async def on_unmount(self) -> None:
+        if self.workflow and self.workflow.is_running:
+            await self.workflow.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_workflow_events(self) -> None:
+        """A background worker that forwards workflow events to the state store and updates the UI."""
+        if not self.workflow_stream: return
+        try:
+            async for event in self.workflow_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.
+                # This is for components like the FocusPane's text stream, which needs
+                # to be as low-latency as possible. The actual UI update is buffered.
+                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 the event is for the currently focused agent, send the event
+                    # to be buffered and eventually rendered.
+                    if is_currently_focused:
+                        await focus_pane.add_agent_event(agent_event)
+
+        except asyncio.CancelledError:
+            logger.info("Workflow event listener task was cancelled.")
+        except Exception:
+            logger.error("Critical error in workflow TUI event listener", exc_info=True)
+        finally:
+            if self.workflow_stream: await self.workflow_stream.close()
+
+    # --- Reactive Watchers ---
+
+    async def watch_store_version(self, new_version: int):
+        """
+        Reacts to changes in the store version. This is now called by the throttled
+        updater, not on every event. Its main job is to update less-frequently
+        changing components like the sidebar tree and workflow dashboards.
+        """
+        sidebar = self.query_one(AgentListSidebar)
+        focus_pane = self.query_one(FocusPane)
+
+        # Fetch fresh data from the store for the update
+        tree_data = self.store.get_tree_data()
+        agent_phases = self.store._agent_phases
+        workflow_phases = self.store._workflow_phases
+        speaking_agents = self.store._speaking_agents
+        
+        # Update sidebar
+        sidebar.update_tree(tree_data, agent_phases, workflow_phases, speaking_agents)
+        
+        # Intelligently update the focus pane
+        focused_data = self.focused_node_data
+        if focused_data and focused_data.get("type") in ['workflow', 'subworkflow']:
+            # If a workflow/subworkflow is focused, its dashboard might be out of date.
+            # A full re-render is cheap and ensures consistency for its title and panels.
+            history = self.store.get_history_for_node(focused_data['name'], focused_data['type'])
+            await focus_pane.update_content(
+                node_data=focused_data,
+                history=history,
+                pending_approval=None,
+                all_agent_phases=agent_phases,
+                all_workflow_phases=workflow_phases
+            )
+        elif focused_data and focused_data.get("type") == 'agent':
+            # For agents, we only need to update the title status, not the whole log.
+            focus_pane.update_current_node_status(agent_phases, workflow_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
+        
+        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_workflow_phases=self.store._workflow_phases
+        )
+        
+        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.workflow.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.workflow.post_tool_execution_approval(
+            agent_name=message.agent_name,
+            tool_invocation_id=message.invocation_id,
+            is_approved=message.is_approved,
+            reason=message.reason,
+        )

autobyteus/cli/workflow_tui/state.py

@@ -0,0 +1,189 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/state.py
+"""
+Defines a centralized state store for the TUI application, following state management best practices.
+"""
+import logging
+from typing import Dict, List, Optional, Any
+import copy
+
+from autobyteus.agent.context import AgentConfig
+from autobyteus.workflow.agentic_workflow import AgenticWorkflow
+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, ToolInvocationApprovalRequestedData, 
+    AssistantChunkData, AssistantCompleteResponseData
+)
+from autobyteus.workflow.streaming.workflow_stream_events import WorkflowStreamEvent
+from autobyteus.workflow.streaming.workflow_stream_event_payloads import AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload, WorkflowPhaseTransitionData
+
+logger = logging.getLogger(__name__)
+
+class TUIStateStore:
+    """
+    A centralized store for all TUI-related state.
+
+    This class acts as the single source of truth for the UI. It processes events
+    from the backend and updates its state. The main App class can then react to
+    these state changes to update the UI components declaratively. This is a plain
+    Python class and does not use Textual reactive properties.
+    """
+
+    def __init__(self, workflow: AgenticWorkflow):
+        self.workflow_name = workflow.name
+        self.workflow_role = workflow.role
+        
+        self.focused_node_data: Optional[Dict[str, Any]] = None
+        
+        self._node_roles: Dict[str, str] = self._extract_node_roles(workflow)
+        self._nodes: Dict[str, Any] = self._initialize_root_node()
+        self._agent_phases: Dict[str, AgentOperationalPhase] = {}
+        self._workflow_phases: Dict[str, WorkflowOperationalPhase] = {self.workflow_name: WorkflowOperationalPhase.UNINITIALIZED}
+        self._agent_event_history: Dict[str, List[AgentStreamEvent]] = {}
+        self._workflow_event_history: Dict[str, List[WorkflowStreamEvent]] = {self.workflow_name: []}
+        self._pending_approvals: Dict[str, ToolInvocationApprovalRequestedData] = {}
+        self._speaking_agents: Dict[str, bool] = {}
+        
+        # REMOVED: The complex stream aggregator is the source of the bug.
+        # self._agent_stream_aggregators: Dict[str, Dict[str, str]] = {}
+
+        # Version counter to signal state changes to the UI
+        self.version = 0
+
+    def _extract_node_roles(self, workflow: AgenticWorkflow) -> Dict[str, str]:
+        """Builds a map of node names to their defined roles from the config."""
+        roles = {}
+        if workflow._runtime and workflow._runtime.context and workflow._runtime.context.config:
+            for node_config in workflow._runtime.context.config.nodes:
+                role = getattr(node_config.node_definition, 'role', None)
+                if role:
+                    roles[node_config.name] = role
+        return roles
+
+    def _initialize_root_node(self) -> Dict[str, Any]:
+        """Creates the initial root node for the state tree."""
+        return {
+            self.workflow_name: {
+                "type": "workflow",
+                "name": self.workflow_name,
+                "role": self.workflow_role,
+                "children": {}
+            }
+        }
+
+    def process_event(self, event: WorkflowStreamEvent):
+        """
+        The main entry point for processing events from the backend.
+        This method acts as a reducer, updating the state based on the event.
+        """
+        if event.event_source_type == "WORKFLOW" and isinstance(event.data, WorkflowPhaseTransitionData):
+            self._workflow_phases[self.workflow_name] = event.data.new_phase
+        
+        self._process_event_recursively(event, self.workflow_name)
+        
+        # Increment version to signal that the state has changed.
+        self.version += 1
+
+    # REMOVED: The flush aggregator logic is no longer needed.
+    # def _flush_aggregator_for_agent(self, agent_name: str): ...
+
+    def _process_event_recursively(self, event: WorkflowStreamEvent, parent_name: str):
+        """Recursively processes events to build up the state tree."""
+        if parent_name not in self._workflow_event_history:
+            self._workflow_event_history[parent_name] = []
+        self._workflow_event_history[parent_name].append(event)
+
+        # AGENT EVENT (LEAF NODE)
+        if isinstance(event.data, AgentEventRebroadcastPayload):
+            payload = event.data
+            agent_name = payload.agent_name
+            agent_event = payload.agent_event
+
+            if agent_name not in self._agent_event_history:
+                self._agent_event_history[agent_name] = []
+                if self._find_node(parent_name):
+                    agent_role = self._node_roles.get(agent_name, "Agent")
+                    self._add_node(agent_name, {"type": "agent", "name": agent_name, "role": agent_role, "children": {}}, parent_name)
+                else:
+                    logger.error(f"Cannot add agent node '{agent_name}': parent '{parent_name}' not found in state tree.")
+
+            # SIMPLIFIED LOGIC: Always append the event to the history, regardless of focus.
+            # This ensures the history is always a complete and accurate log of what happened.
+            self._agent_event_history[agent_name].append(agent_event)
+
+            # --- State update logic for specific events (applies to both focused and non-focused) ---
+            if agent_event.event_type == AgentStreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION:
+                phase_data: AgentOperationalPhaseTransitionData = agent_event.data
+                self._agent_phases[agent_name] = phase_data.new_phase
+                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
+
+        # SUB-WORKFLOW EVENT (BRANCH NODE)
+        elif isinstance(event.data, SubWorkflowEventRebroadcastPayload):
+            payload = event.data
+            sub_workflow_name = payload.sub_workflow_node_name
+            sub_workflow_event = payload.sub_workflow_event
+            
+            sub_workflow_node = self._find_node(sub_workflow_name)
+            if not sub_workflow_node:
+                role = self._node_roles.get(sub_workflow_name, "Sub-Workflow")
+                self._add_node(sub_workflow_name, {"type": "subworkflow", "name": sub_workflow_name, "role": role, "children": {}}, parent_name)
+
+            if sub_workflow_event.event_source_type == "WORKFLOW" and isinstance(sub_workflow_event.data, WorkflowPhaseTransitionData):
+                self._workflow_phases[sub_workflow_name] = sub_workflow_event.data.new_phase
+
+            self._process_event_recursively(sub_workflow_event, parent_name=sub_workflow_name)
+
+    def _add_node(self, node_name: str, node_data: Dict, parent_name: str):
+        """Adds a node to the state tree under a specific parent."""
+        parent = self._find_node(parent_name)
+        if parent:
+            parent["children"][node_name] = node_data
+        else:
+            logger.error(f"Could not find parent node '{parent_name}' to add child '{node_name}'.")
+
+    def _find_node(self, node_name: str, tree: Optional[Dict] = None) -> Optional[Dict]:
+        """Recursively finds a node by name in the state tree."""
+        if tree is None:
+            tree = self._nodes
+        
+        for name, node_data in tree.items():
+            if name == node_name:
+                return node_data
+            if node_data.get("children"):
+                found = self._find_node(node_name, node_data.get("children"))
+                if found:
+                    return found
+        return None
+
+    def get_tree_data(self) -> Dict:
+        """Constructs a serializable representation of the tree for the sidebar."""
+        return copy.deepcopy(self._nodes)
+    
+    def get_history_for_node(self, node_name: str, node_type: str) -> List:
+        """Retrieves the event history for a given node."""
+        if node_type == 'agent':
+            # REMOVED: Flushing is no longer necessary as the history is always complete.
+            return self._agent_event_history.get(node_name, [])
+        elif node_type in ['workflow', 'subworkflow']:
+            return []
+        return []
+        
+    def get_pending_approval_for_agent(self, agent_name: str) -> Optional[ToolInvocationApprovalRequestedData]:
+        """Gets pending approval data for a specific agent."""
+        return self._pending_approvals.get(agent_name)
+
+    def clear_pending_approval(self, agent_name: str):
+        """Clears a pending approval after it's been handled."""
+        if agent_name in self._pending_approvals:
+            del self._pending_approvals[agent_name]
+    
+    def set_focused_node(self, node_data: Optional[Dict[str, Any]]):
+        """Sets the currently focused node in the state."""
+        # REMOVED: Flushing logic is no longer needed here.
+        self.focused_node_data = node_data

autobyteus/cli/workflow_tui/widgets/__init__.py

@@ -0,0 +1,6 @@
+# file: autobyteus/autobyteus/cli/workflow_tui/widgets/__init__.py
+"""
+Custom Textual widgets for the workflow TUI.
+"""
+from . import renderables
+from .logo import Logo