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

autobyteus/cli/workflow_tui/widgets/focus_pane.py

@@ -13,15 +13,17 @@ 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.status.status_enum import AgentStatus
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 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
+    AgentStatusUpdateData, AssistantChunkData, AssistantCompleteResponseData,
+    ErrorEventData, ToolInteractionLogEntryData, ToolInvocationApprovalRequestedData, ToolInvocationAutoExecutingData,
+    SegmentEventData,
 )
+from autobyteus.agent.streaming.parser.events import SegmentEventType, SegmentType
 from .shared import (
-    AGENT_PHASE_ICONS, WORKFLOW_PHASE_ICONS, SUB_WORKFLOW_ICON, DEFAULT_ICON,
+    AGENT_STATUS_ICONS, WORKFLOW_STATUS_ICONS, SUB_WORKFLOW_ICON, DEFAULT_ICON,
     USER_ICON, ASSISTANT_ICON, WORKFLOW_ICON, AGENT_ICON
 )
 from . import renderables
@@ -62,6 +64,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")
@@ -127,7 +131,7 @@ class FocusPane(Static):
             Button("Deny", variant="error", id="deny-btn")
         )
 
-    def _update_title(self, agent_phases: Dict[str, AgentOperationalPhase], workflow_phases: Dict[str, WorkflowOperationalPhase]):
+    def _update_title(self, agent_statuses: Dict[str, AgentStatus], workflow_statuses: Dict[str, WorkflowStatus]):
         """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")
@@ -138,31 +142,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 == 'subworkflow':
             title_icon = SUB_WORKFLOW_ICON
-            phase = workflow_phases.get(node_name, WorkflowOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = workflow_statuses.get(node_name, WorkflowStatus.UNINITIALIZED)
+            status_str = f" (Status: {status.value})"
         elif node_type == 'workflow':
             title_icon = WORKFLOW_ICON
-            phase = workflow_phases.get(node_name, WorkflowOperationalPhase.UNINITIALIZED)
-            phase_str = f" (Status: {phase.value})"
+            status = workflow_statuses.get(node_name, WorkflowStatus.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_workflow_phases: Dict):
+    def update_current_node_status(self, all_agent_statuses: Dict, all_workflow_statuses: Dict):
         """A lightweight method to only update the title with the latest status."""
-        self._update_title(all_agent_phases, all_workflow_phases)
+        self._update_title(all_agent_statuses, all_workflow_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_workflow_phases: Dict[str, WorkflowOperationalPhase]):
+                             all_agent_statuses: Dict[str, AgentStatus], 
+                             all_workflow_statuses: Dict[str, WorkflowStatus]):
         """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()
@@ -170,7 +174,7 @@ class FocusPane(Static):
         self._focused_node_data = node_data
         self._pending_approval_data = pending_approval
         
-        self._update_title(all_agent_phases, all_workflow_phases)
+        self._update_title(all_agent_statuses, all_workflow_statuses)
 
         log_container = self.query_one("#focus-pane-log-container")
         await log_container.remove_children()
@@ -180,6 +184,8 @@ class FocusPane(Static):
         self._thinking_text = None
         self._assistant_content_widget = None
         self._assistant_content_text = None
+        self._segment_types_by_id.clear()
+        self._saw_segment_event = False
 
         await self._clear_approval_ui()
 
@@ -189,21 +195,21 @@ class FocusPane(Static):
             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)
+            await self._render_workflow_dashboard(node_data, all_agent_statuses, all_workflow_statuses)
 
     async def _render_workflow_dashboard(self, node_data: Dict[str, Any], 
-                                         all_agent_phases: Dict[str, AgentOperationalPhase],
-                                         all_workflow_phases: Dict[str, WorkflowOperationalPhase]):
+                                         all_agent_statuses: Dict[str, AgentStatus],
+                                         all_workflow_statuses: Dict[str, WorkflowStatus]):
         """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)
+        status = all_workflow_statuses.get(node_data['name'], WorkflowStatus.UNINITIALIZED)
+        status_icon = WORKFLOW_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="Workflow Info", border_style="green", title_align="left")))
 
         children_data = node_data.get("children", {})
@@ -211,13 +217,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'] == '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")
+                    wf_status = all_workflow_statuses.get(name, WorkflowStatus.UNINITIALIZED)
+                    wf_icon = WORKFLOW_STATUS_ICONS.get(wf_status, SUB_WORKFLOW_ICON)
+                    team_text.append(f" ▪ {wf_icon} {name} (Sub-Workflow): {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):
@@ -249,12 +255,107 @@ 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()
+            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)
+
+    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):
         """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.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:
@@ -276,7 +377,7 @@ class FocusPane(Static):
                     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.
+            return
 
         # Handle the explicit end of a stream
         if event_type == AgentStreamEventType.ASSISTANT_COMPLETE_RESPONSE:
@@ -287,13 +388,14 @@ class FocusPane(Static):
             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:
+            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  # This event's purpose is to end the stream.
 
         # For all other events, first check if they should break an ongoing stream.
@@ -324,7 +426,7 @@ class FocusPane(Static):
             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]:
+        elif event_type == AgentStreamEventType.AGENT_STATUS_UPDATED:
             # These are informational and do not have a renderable in the log pane.
             pass
 

autobyteus/cli/workflow_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
 )
 from .shared import ASSISTANT_ICON, TOOL_ICON, PROMPT_ICON, ERROR_ICON, LOG_ICON

autobyteus/cli/workflow_tui/widgets/shared.py

@@ -3,33 +3,33 @@
 Shared constants and data for TUI widgets.
 """
 from typing import Dict
-from autobyteus.agent.phases import AgentOperationalPhase
-from autobyteus.workflow.phases import WorkflowOperationalPhase
+from autobyteus.agent.status.status_enum import AgentStatus
+from autobyteus.workflow.status.workflow_status import WorkflowStatus
 
-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: "❗",
 }
 
-WORKFLOW_PHASE_ICONS: Dict[WorkflowOperationalPhase, str] = {
-    WorkflowOperationalPhase.UNINITIALIZED: "⚪",
-    WorkflowOperationalPhase.BOOTSTRAPPING: "⏳",
-    WorkflowOperationalPhase.IDLE: "🟢",
-    WorkflowOperationalPhase.PROCESSING: "⚙️",
-    WorkflowOperationalPhase.SHUTTING_DOWN: "🌙",
-    WorkflowOperationalPhase.SHUTDOWN_COMPLETE: "⚫",
-    WorkflowOperationalPhase.ERROR: "❗",
+WORKFLOW_STATUS_ICONS: Dict[WorkflowStatus, str] = {
+    WorkflowStatus.UNINITIALIZED: "⚪",
+    WorkflowStatus.BOOTSTRAPPING: "⏳",
+    WorkflowStatus.IDLE: "🟢",
+    WorkflowStatus.PROCESSING: "⚙️",
+    WorkflowStatus.SHUTTING_DOWN: "🌙",
+    WorkflowStatus.SHUTDOWN_COMPLETE: "⚫",
+    WorkflowStatus.ERROR: "❗",
 }
 
 # Main component icons
@@ -47,5 +47,5 @@ ASSISTANT_ICON = "🤖"
 TOOL_ICON = "🛠️"
 PROMPT_ICON = "❓"
 ERROR_ICON = "💥"
-PHASE_ICON = "🔄"
+STATUS_ICON = "🔄"
 LOG_ICON = "📄"

autobyteus/clients/autobyteus_client.py

@@ -102,6 +102,30 @@ class AutobyteusClient:
 
         logger.info("Initialized Autobyteus client with server URL: %s", self.server_url)
 
+    @staticmethod
+    def _wrap_http_error(exc: httpx.HTTPStatusError) -> RuntimeError:
+        """
+        Produce a RuntimeError that preserves status code and server-provided details.
+        """
+        response = exc.response
+        detail: str = ""
+        # Prefer JSON "detail" if present
+        try:
+            json_body = response.json()
+            detail = json_body.get("detail") or json.dumps(json_body)
+        except Exception:
+            # Fall back to raw text
+            detail = response.text
+
+        message = f"HTTP {response.status_code} {response.reason_phrase}"
+        if detail:
+            message = f"{message}: {detail}"
+        else:
+            message = f"{message}: {exc}"
+        err = RuntimeError(message)
+        err.__cause__ = exc
+        return err
+
     async def get_available_llm_models(self) -> Dict[str, Any]:
         """Async discovery of available LLM models."""
         try:
@@ -110,6 +134,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Async LLM model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Async LLM model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -120,6 +147,9 @@ class AutobyteusClient:
             response = self.sync_client.get(urljoin(self.server_url, "/models/llm"))
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Sync LLM model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Sync LLM model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -132,6 +162,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Async image model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Async image model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -144,6 +177,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Sync image model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Sync image model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -156,6 +192,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Async audio model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Async audio model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -168,6 +207,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Sync audio model fetch error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Sync audio model fetch error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -197,6 +239,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Error sending message: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Error sending message: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -239,6 +284,9 @@ class AutobyteusClient:
                             logger.error("Failed to parse stream chunk: %s", exc)
                             raise RuntimeError("Invalid stream response format") from exc
 
+        except httpx.HTTPStatusError as exc:
+            logger.error("Stream error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Stream error: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -250,6 +298,7 @@ class AutobyteusClient:
         input_image_urls: Optional[List[str]] = None,
         mask_url: Optional[str] = None,
         generation_config: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Generate or edit an image and return the server response."""
         try:
@@ -259,6 +308,7 @@ class AutobyteusClient:
                 "input_image_urls": input_image_urls or [],
                 "mask_url": mask_url,
                 "generation_config": generation_config or {},
+                "session_id": session_id,
             }
             response = await self.async_client.post(
                 urljoin(self.server_url, "/generate-image"),
@@ -266,6 +316,9 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Error generating image: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Error generating image: %s", exc)
             raise RuntimeError(str(exc)) from exc
@@ -275,6 +328,7 @@ class AutobyteusClient:
         model_name: str,
         prompt: str,
         generation_config: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Generate speech from text and return the server response."""
         try:
@@ -282,6 +336,7 @@ class AutobyteusClient:
                 "model_name": model_name,
                 "prompt": prompt,
                 "generation_config": generation_config or {},
+                "session_id": session_id,
             }
             response = await self.async_client.post(
                 urljoin(self.server_url, "/generate-speech"),
@@ -289,12 +344,15 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Error generating speech: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Error generating speech: %s", exc)
             raise RuntimeError(str(exc)) from exc
 
     async def cleanup(self, conversation_id: str) -> Dict[str, Any]:
-        """Clean up a conversation."""
+        """Clean up a conversation (LLM)."""
         try:
             response = await self.async_client.post(
                 urljoin(self.server_url, "/cleanup"),
@@ -302,10 +360,45 @@ class AutobyteusClient:
             )
             response.raise_for_status()
             return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Cleanup error: %s", exc)
+            raise self._wrap_http_error(exc)
         except httpx.HTTPError as exc:
             logger.error("Cleanup error: %s", exc)
             raise RuntimeError(str(exc)) from exc
 
+    async def cleanup_image_session(self, session_id: str) -> Dict[str, Any]:
+        """Clean up an image session."""
+        try:
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/cleanup/image"),
+                json={"session_id": session_id},
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Image session cleanup error: %s", exc)
+            raise self._wrap_http_error(exc)
+        except httpx.HTTPError as exc:
+            logger.error("Image session cleanup error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def cleanup_audio_session(self, session_id: str) -> Dict[str, Any]:
+        """Clean up an audio session."""
+        try:
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/cleanup/audio"),
+                json={"session_id": session_id},
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as exc:
+            logger.error("Audio session cleanup error: %s", exc)
+            raise self._wrap_http_error(exc)
+        except httpx.HTTPError as exc:
+            logger.error("Audio session cleanup error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
     async def close(self) -> None:
         """Close both HTTP clients."""
         await self.async_client.aclose()

autobyteus/events/event_types.py

@@ -4,51 +4,45 @@ from enum import Enum
 class EventType(Enum): 
     """
     Defines the types of events that can be emitted by EventEmitters within the system.
-    Uses prefixes like AGENT_PHASE_, AGENT_DATA_, AGENT_REQUEST_, AGENT_ERROR_ for clarity.
+    Uses prefixes like AGENT_STATUS_, AGENT_DATA_, AGENT_REQUEST_, AGENT_ERROR_ for clarity.
     """
     # --- Non-Agent specific events ---
     WEIBO_POST_COMPLETED = "weibo_post_completed" # Example, keep as is
     TOOL_EXECUTION_COMPLETED = "tool_execution_completed" # Added for generic tool events
-    TIMER_UPDATE = "timer_update" # Added for Timer tool
     SHARED_BROWSER_SESSION_CREATED = "shared_browser_session_created" # Added for session-aware tools
     CREATE_SHARED_SESSION = "create_shared_session" # Added for session-aware tools
 
-    # --- Agent Phase Transitions ---
-    AGENT_PHASE_UNINITIALIZED_ENTERED = "agent_phase_uninitialized_entered"
-    AGENT_PHASE_BOOTSTRAPPING_STARTED = "agent_phase_bootstrapping_started"
-    AGENT_PHASE_IDLE_ENTERED = "agent_phase_idle_entered"
-    AGENT_PHASE_PROCESSING_USER_INPUT_STARTED = "agent_phase_processing_user_input_started"
-    AGENT_PHASE_AWAITING_LLM_RESPONSE_STARTED = "agent_phase_awaiting_llm_response_started"
-    AGENT_PHASE_ANALYZING_LLM_RESPONSE_STARTED = "agent_phase_analyzing_llm_response_started"
-    AGENT_PHASE_AWAITING_TOOL_APPROVAL_STARTED = "agent_phase_awaiting_tool_approval_started" 
-    AGENT_PHASE_TOOL_DENIED_STARTED = "agent_phase_tool_denied_started"
-    AGENT_PHASE_EXECUTING_TOOL_STARTED = "agent_phase_executing_tool_started"
-    AGENT_PHASE_PROCESSING_TOOL_RESULT_STARTED = "agent_phase_processing_tool_result_started"
-    AGENT_PHASE_SHUTTING_DOWN_STARTED = "agent_phase_shutting_down_started"
-    AGENT_PHASE_SHUTDOWN_COMPLETED = "agent_phase_shutdown_completed"
-    AGENT_PHASE_ERROR_ENTERED = "agent_phase_error_entered" 
+    # --- Agent Status Updates ---
+    AGENT_STATUS_UPDATED = "agent_status_updated"
 
     # --- Agent Data Outputs ---
     AGENT_DATA_ASSISTANT_CHUNK = "agent_data_assistant_chunk" 
-    AGENT_DATA_ASSISTANT_CHUNK_STREAM_END = "agent_data_assistant_chunk_stream_end" 
     AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE = "agent_data_assistant_complete_response"
+    AGENT_DATA_SEGMENT_EVENT = "agent_data_segment_event"  # Streaming parser segment events
     AGENT_DATA_TOOL_LOG = "agent_data_tool_log" 
     AGENT_DATA_TOOL_LOG_STREAM_END = "agent_data_tool_log_stream_end" 
     AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED = "agent_data_system_task_notification_received" # NEW
+    AGENT_DATA_INTER_AGENT_MESSAGE_RECEIVED = "agent_data_inter_agent_message_received"  # NEW: surface inter-agent messages
+    AGENT_DATA_TODO_LIST_UPDATED = "agent_data_todo_list_updated"
+    AGENT_ARTIFACT_PERSISTED = "agent_artifact_persisted" # NEW: artifact persistence confirmation
+    AGENT_ARTIFACT_UPDATED = "agent_artifact_updated" # NEW: artifact content updated (e.g., patch_file)
     
     # --- Agent Requests for External Interaction ---
     AGENT_REQUEST_TOOL_INVOCATION_APPROVAL = "agent_request_tool_invocation_approval" 
     AGENT_TOOL_INVOCATION_AUTO_EXECUTING = "agent_tool_invocation_auto_executing"
     
-    # --- Agent Errors (not necessarily phase changes, e.g., error during output generation) ---
+    # --- Agent Errors (not necessarily status changes, e.g., error during output generation) ---
     AGENT_ERROR_OUTPUT_GENERATION = "agent_error_output_generation"
 
     # --- Agent Team Events ---
     TEAM_STREAM_EVENT = "team_stream_event" # For unified agent team event stream
 
-    # --- Task Board Events ---
-    TASK_BOARD_TASKS_ADDED = "task_board.tasks.added"
-    TASK_BOARD_STATUS_UPDATED = "task_board.status.updated"
+    # --- Workflow Events ---
+    WORKFLOW_STREAM_EVENT = "workflow_stream_event" # For unified workflow event stream
+
+    # --- Task Plan Events ---
+    TASK_PLAN_TASKS_CREATED = "task_plan.tasks.created"
+    TASK_PLAN_STATUS_UPDATED = "task_plan.status.updated"
 
     def __str__(self): 
         return self.value