fix: stream debug run in console

Author: cristipufu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.2.22"
+version = "2.2.23"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

src/uipath/_cli/_chat/_protocol.py src/uipath/_cli/_chat/_bridge.pysrc/uipath/_cli/_chat/_protocol.py renamed to src/uipath/_cli/_chat/_bridge.py

@@ -7,18 +7,126 @@
 from urllib.parse import urlparse
 
 import socketio  # type: ignore[import-untyped]
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
 from socketio import AsyncClient
 from uipath.core.chat import (
     UiPathConversationEvent,
     UiPathConversationExchangeEndEvent,
     UiPathConversationExchangeEvent,
+    UiPathConversationMessageEvent,
+    UiPathConversationMessageStartEvent,
 )
 from uipath.runtime.chat import UiPathChatProtocol
 from uipath.runtime.context import UiPathRuntimeContext
 
 logger = logging.getLogger(__name__)
 
 
+class ConsoleChatBridge(UiPathChatProtocol):
+    """Console implementation of UiPathChatProtocol that streams message content."""
+
+    def __init__(self):
+        self.console = Console(force_terminal=True)
+        self._connected = False
+
+        self._live: Live | None = None
+        self._buffer: list[str] = []
+        self._current_role: str | None = None
+
+    async def connect(self) -> None:
+        self._connected = True
+        self.console.print(
+            Panel("[bold green]Console Chat Started[/bold green]", expand=False)
+        )
+
+    async def disconnect(self) -> None:
+        if self._live:
+            self._live.stop()
+        self.console.print(
+            Panel("[bold red]Console Chat Ended[/bold red]", expand=False)
+        )
+        self._connected = False
+
+    async def emit_message_event(self, event: UiPathConversationMessageEvent) -> None:
+        """Handles *all* message-level events."""
+        if not self._connected:
+            return
+
+        if event.start:
+            await self._on_message_start(event.start)
+
+        if event.content_part:
+            cp = event.content_part
+
+            if cp.start:
+                await self._on_content_part_start(cp.start.mime_type)
+
+            if cp.chunk:
+                await self._on_content_part_chunk(cp.chunk.data or "")
+
+            if cp.end:
+                await self._on_content_part_end()
+
+        if event.end:
+            await self._on_message_end()
+
+    async def _on_message_start(self, start: UiPathConversationMessageStartEvent):
+        self._current_role = start.role or "assistant"
+        self.console.print(
+            Panel(
+                "[bold blue]User[/bold blue]"
+                if self._current_role == "user"
+                else "[bold green]Assistant[/bold green]",
+                expand=False,
+            )
+        )
+
+    async def _on_message_end(self):
+        if self._live:
+            self._live.stop()
+            self._live = None
+            self._buffer = []
+
+    async def _on_content_part_start(self, mime_type: str):
+        """Prepare to stream a content part of a message."""
+        self._buffer = []
+
+        if not self._live:
+            self._live = Live(auto_refresh=False)
+            self._live.start()
+
+    async def _on_content_part_chunk(self, text: str):
+        """Stream one chunk of assistant text."""
+        if not self._live:
+            # Should never happen, but safe guard
+            self._live = Live(auto_refresh=False)
+            self._live.start()
+
+        self._buffer.append(text)
+
+        rendered = Markdown("".join(self._buffer))
+        self._live.update(
+            Panel(rendered, title="[green]Assistant (streaming)"),
+        )
+        self._live.refresh()
+
+    async def _on_content_part_end(self):
+        """Finalize streaming for this part (but message may continue)."""
+        if self._live:
+            self._live.stop()
+            self._live = None
+
+        # Print the final assembled text once more
+        final_text = "".join(self._buffer)
+        self.console.print(
+            Panel(Markdown(final_text), expand=False, border_style="green")
+        )
+        self._buffer = []
+
+
 class WebSocketChatBridge:
     """WebSocket-based chat bridge for streaming conversational events to CAS.
 

src/uipath/_cli/cli_run.py

@@ -10,11 +10,13 @@
     UiPathRuntimeResult,
     UiPathStreamOptions,
 )
+from uipath.runtime.chat import UiPathChatProtocol
 from uipath.runtime.context import UiPathRuntimeContext
 from uipath.runtime.debug import UiPathDebugBridgeProtocol
 from uipath.runtime.errors import UiPathRuntimeError
-from uipath.runtime.events import UiPathRuntimeStateEvent
+from uipath.runtime.events import UiPathRuntimeMessageEvent, UiPathRuntimeStateEvent
 
+from uipath._cli._chat._bridge import ConsoleChatBridge
 from uipath._cli._debug._bridge import ConsoleDebugBridge
 from uipath._cli._utils._common import read_resource_overwrites_from_file
 from uipath._cli._utils._debug import setup_debugging
@@ -122,14 +124,20 @@ async def debug_runtime(
                 ctx: UiPathRuntimeContext, runtime: UiPathRuntimeProtocol
             ) -> UiPathRuntimeResult | None:
                 debug_bridge: UiPathDebugBridgeProtocol = ConsoleDebugBridge()
+                chat_bridge: UiPathChatProtocol = ConsoleChatBridge()
+
                 await debug_bridge.emit_execution_started()
+                await chat_bridge.connect()
                 options = UiPathStreamOptions(resume=resume)
                 async for event in runtime.stream(ctx.get_input(), options=options):
                     if isinstance(event, UiPathRuntimeResult):
                         await debug_bridge.emit_execution_completed(event)
+                        await chat_bridge.disconnect()
                         ctx.result = event
                     elif isinstance(event, UiPathRuntimeStateEvent):
                         await debug_bridge.emit_state_update(event)
+                    elif isinstance(event, UiPathRuntimeMessageEvent):
+                        await chat_bridge.emit_message_event(event)
                 return ctx.result
 
             async def execute() -> None: