Merge pull request #550 from UiPath/feat/chat_interface

feat: chat interface

Author: cristipufu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.36"
+version = "2.1.37"
 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.10"

src/uipath/_cli/_dev/_terminal/__init__.py

@@ -9,10 +9,13 @@
 
 import pyperclip  # type: ignore[import-untyped]
 from rich.traceback import Traceback
+from textual import on
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Container, Horizontal
-from textual.widgets import Button, Footer, ListView, RichLog
+from textual.widgets import Button, Footer, Input, ListView, RichLog
+
+from uipath.agent.conversation import UiPathConversationEvent
 
 from ..._runtime._contracts import (
     UiPathErrorContract,
@@ -24,16 +27,18 @@
 from ._components._details import RunDetailsPanel
 from ._components._history import RunHistoryPanel
 from ._components._new import NewRunPanel
-from ._components._resume import ResumePanel
 from ._models._execution import ExecutionRun
 from ._models._messages import LogMessage, TraceMessage
-from ._traces._exporter import RunContextExporter
-from ._traces._logger import RunContextLogHandler
+from ._utils._chat import RunContextChatHandler, build_user_message_event
+from ._utils._exporter import RunContextExporter
+from ._utils._logger import RunContextLogHandler
 
 
 class UiPathDevTerminal(App[Any]):
-    """UiPath development terminal interface."""
+    """UiPath debugging terminal interface."""
 
+    TITLE = "UiPath Debugging Terminal"
+    SUB_TITLE = "Interactive debugging interface for UiPath Python projects"
     CSS_PATH = Path(__file__).parent / "_styles" / "terminal.tcss"
 
     BINDINGS = [
@@ -91,8 +96,6 @@ async def on_button_pressed(self, event: Button.Pressed) -> None:
             await self.action_execute_run()
         elif event.button.id == "cancel-btn":
             await self.action_cancel()
-        elif event.button.id == "resume-btn":
-            await self.action_resume()
 
     async def on_list_view_selected(self, event: ListView.Selected) -> None:
         """Handle run selection from history."""
@@ -104,6 +107,31 @@ async def on_list_view_selected(self, event: ListView.Selected) -> None:
                 if run:
                     self._show_run_details(run)
 
+    @on(Input.Submitted, "#chat-input")
+    async def handle_chat_input(self, event: Input.Submitted) -> None:
+        """Handle user submitting text into the chat."""
+        user_text = event.value.strip()
+        if not user_text:
+            return
+
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        if details_panel and details_panel.current_run:
+            if details_panel.current_run.status != "suspended":
+                self.app.notify(
+                    "Wait for agent response...", timeout=1.5, severity="warning"
+                )
+                return
+            self._handle_chat_event(
+                build_user_message_event(
+                    user_text=user_text,
+                    conversation_id=details_panel.current_run.id,
+                ),
+                details_panel.current_run.id,
+            )
+            details_panel.current_run.resume_data = {"value": user_text}
+            asyncio.create_task(self._execute_runtime(details_panel.current_run))
+            event.input.clear()
+
     async def action_new_run(self) -> None:
         """Show new run panel."""
         new_panel = self.query_one("#new-run-panel")
@@ -116,20 +144,6 @@ async def action_cancel(self) -> None:
         """Cancel and return to new run view."""
         await self.action_new_run()
 
-    async def action_resume(self) -> None:
-        """Resume the suspended run."""
-        details_panel = self.query_one("#details-panel", RunDetailsPanel)
-        if details_panel and details_panel.current_run:
-            input: Dict[str, Any] = {}
-            input_data = self.query_one("#resume-panel", ResumePanel).get_input_values()
-            try:
-                input = json.loads(input_data)
-            except json.JSONDecodeError:
-                return
-            details_panel.current_run.resume_data = input
-            asyncio.create_task(self._execute_runtime(details_panel.current_run))
-            details_panel.switch_tab("run-tab")
-
     async def action_execute_run(self) -> None:
         """Execute a new run with UiPath runtime."""
         new_run_panel = self.query_one("#new-run-panel", NewRunPanel)
@@ -179,7 +193,10 @@ async def _execute_runtime(self, run: ExecutionRun):
                 execution_id=run.id,
                 logs_min_level=env.get("LOG_LEVEL", "INFO"),
                 log_handler=RunContextLogHandler(
-                    run_id=run.id, on_log=self._handle_log_message
+                    run_id=run.id, callback=self._handle_log_message
+                ),
+                chat_handler=RunContextChatHandler(
+                    run_id=run.id, callback=self._handle_chat_event
                 ),
             )
 
@@ -271,6 +288,15 @@ def _handle_log_message(self, log_msg: LogMessage):
         details_panel = self.query_one("#details-panel", RunDetailsPanel)
         details_panel.add_log(log_msg)
 
+    def _handle_chat_event(
+        self, event: UiPathConversationEvent, execution_id: str
+    ) -> None:
+        updated_chat_message = self.runs[execution_id].add_message(event)
+        if not updated_chat_message:
+            return
+        details_panel = self.app.query_one("#details-panel", RunDetailsPanel)
+        details_panel.add_chat_message(updated_chat_message, execution_id)
+
     def _add_info_log(self, run: ExecutionRun, message: str):
         """Add info log to run."""
         timestamp = datetime.now()

src/uipath/_cli/_dev/_terminal/_components/_chat.py

@@ -0,0 +1,98 @@
+import time
+from typing import Dict, List, Union
+
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical, VerticalScroll
+from textual.widgets import Input, Markdown
+
+from uipath.agent.conversation import (
+    UiPathConversationMessage,
+    UiPathExternalValue,
+    UiPathInlineValue,
+)
+
+
+class Prompt(Markdown):
+    pass
+
+
+class Response(Markdown):
+    BORDER_TITLE = "ai"
+
+
+class Tool(Markdown):
+    BORDER_TITLE = "tool"
+
+
+class ChatPanel(Container):
+    """Panel for displaying and interacting with chat messages."""
+
+    _chat_widgets: Dict[str, Markdown]
+    _last_update_time: Dict[str, float]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._chat_widgets = {}
+        self._last_update_time = {}
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="chat-container"):
+            yield VerticalScroll(id="chat-view")
+            yield Input(
+                placeholder="Type your message and press Enter...",
+                id="chat-input",
+            )
+
+    def add_chat_message(self, chat_msg: UiPathConversationMessage) -> None:
+        """Add or update a chat message bubble."""
+        chat_view = self.query_one("#chat-view")
+
+        widget_cls: Union[type[Prompt], type[Response], type[Tool]]
+        if chat_msg.role == "user":
+            widget_cls = Prompt
+            prefix = "👤"
+        elif chat_msg.role == "assistant":
+            widget_cls = Response
+            prefix = "🤖"
+        else:
+            widget_cls = Response
+            prefix = "⚒️"
+
+        parts: List[str] = []
+        if chat_msg.content_parts:
+            for part in chat_msg.content_parts:
+                if part.mime_type.startswith("text/"):
+                    if isinstance(part.data, UiPathInlineValue):
+                        parts.append(part.data.inline or "")
+                    elif isinstance(part.data, UiPathExternalValue):
+                        # maybe fetch from URL or just show a placeholder
+                        parts.append(f"[external: {part.data.url}]")
+
+        text_block = "\n".join(parts).strip()
+        content_lines = [f"{prefix} {text_block}"] if text_block else []
+
+        if chat_msg.tool_calls:
+            for call in chat_msg.tool_calls:
+                args = call.arguments
+                content_lines.append(f"🛠 **{call.name}**\n{args}")
+
+        if not content_lines:
+            return
+
+        content = "\n\n".join(content_lines)
+
+        existing = self._chat_widgets.get(chat_msg.message_id)
+        now = time.monotonic()
+        last_update = self._last_update_time.get(chat_msg.message_id, 0.0)
+
+        if existing:
+            if now - last_update > 0.15:
+                existing.update(content)
+                self._last_update_time[chat_msg.message_id] = now
+                chat_view.scroll_end(animate=False)
+        else:
+            widget_instance = widget_cls(content)
+            chat_view.mount(widget_instance)
+            self._chat_widgets[chat_msg.message_id] = widget_instance
+            self._last_update_time[chat_msg.message_id] = now
+            chat_view.scroll_end(animate=False)

src/uipath/_cli/_dev/_terminal/_components/_details.py

@@ -3,12 +3,14 @@
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
-from textual.widgets import RichLog, TabbedContent, TabPane, Tree
+from textual.widgets import Input, RichLog, TabbedContent, TabPane, Tree
 from textual.widgets.tree import TreeNode
 
+from uipath.agent.conversation import UiPathConversationMessage
+
 from .._models._execution import ExecutionRun
 from .._models._messages import LogMessage, TraceMessage
-from ._resume import ResumePanel
+from ._chat import ChatPanel
 
 
 class SpanDetailsDisplay(Container):
@@ -116,8 +118,8 @@ def compose(self) -> ComposeResult:
                     classes="detail-log",
                 )
 
-            with TabPane("Resume", id="resume-tab"):
-                yield ResumePanel(id="resume-panel")
+            with TabPane("Chat", id="chat-tab"):
+                yield ChatPanel(id="chat-panel")
 
     def watch_current_run(
         self, old_value: Optional[ExecutionRun], new_value: Optional[ExecutionRun]
@@ -151,9 +153,9 @@ def switch_tab(self, tab_id: str) -> None:
         tabbed = self.query_one(TabbedContent)
         tabbed.active = tab_id
 
-    def _update_resume_tab(self, run: ExecutionRun) -> None:
-        resume_panel = self.query_one("#resume-panel", ResumePanel)
-        resume_panel.display = run.status == "suspended"
+    def _update_chat_tab(self, run: ExecutionRun) -> None:
+        chat_input = self.query_one("#chat-input", Input)
+        chat_input.disabled = run.status == "completed" or run.status == "failed"
 
     def _flatten_values(self, value: object, prefix: str = "") -> list[str]:
         """Flatten nested dict/list structures into dot-notation paths."""
@@ -210,7 +212,7 @@ def _write_block(
 
     def _show_run_details(self, run: ExecutionRun):
         """Display detailed information about the run in the Details tab."""
-        self._update_resume_tab(run)
+        self._update_chat_tab(run)
 
         run_details_log = self.query_one("#run-details-log", RichLog)
         run_details_log.clear()
@@ -427,6 +429,15 @@ def add_log(self, log_msg: LogMessage):
         else:
             logs_log.write(log_msg.message)
 
+    def add_chat_message(
+        self, chat_msg: UiPathConversationMessage, run_id: str
+    ) -> None:
+        """Add a chat message to the display."""
+        if not self.current_run or run_id != self.current_run.id:
+            return
+        chat_panel = self.query_one("#chat-panel", ChatPanel)
+        chat_panel.add_chat_message(chat_msg)
+
     def clear_display(self):
         """Clear both traces and logs display."""
         run_details_log = self.query_one("#run-details-log", RichLog)

src/uipath/_cli/_dev/_terminal/_components/_resume.py

@@ -5,7 +5,10 @@
 
 from rich.text import Text
 
+from uipath.agent.conversation import UiPathConversationEvent, UiPathConversationMessage
+
 from ...._runtime._contracts import UiPathErrorContract
+from .._utils._chat import ConversationAggregator
 from ._messages import LogMessage, TraceMessage
 
 
@@ -24,6 +27,7 @@ def __init__(self, entrypoint: str, input_data: Dict[str, Any]):
         self.traces: List[TraceMessage] = []
         self.logs: List[LogMessage] = []
         self.error: Optional[UiPathErrorContract] = None
+        self.chat_aggregator = ConversationAggregator()
 
     @property
     def duration(self) -> str:
@@ -64,3 +68,12 @@ def display_name(self) -> Text:
         text.append(f"[{duration_str:<6}]")
 
         return text
+
+    @property
+    def messages(self) -> List[UiPathConversationMessage]:
+        return list(self.chat_aggregator.messages.values())
+
+    def add_message(
+        self, event: UiPathConversationEvent
+    ) -> Optional[UiPathConversationMessage]:
+        return self.chat_aggregator.add_event(event)

src/uipath/_cli/_dev/_terminal/_models/_execution.py

@@ -223,3 +223,29 @@ SpanDetailsDisplay {
 TextArea.invalid {
     border: tall red;
 }
+
+
+Prompt {
+    background: $primary 5%;
+    color: $text;
+    margin-right: 8;
+    margin-left: 1;
+    padding: 1 1 0 1;
+}
+Response, Tool {
+    border: wide $success;
+    background: $success 5%;
+    color: $text;
+    margin: 1;
+    margin-left: 8;
+    padding: 1 1 0 1;
+}
+
+#chat-container{
+    background: $surface;
+}
+
+#chat-input{
+    dock: bottom;
+    margin: 1;
+}