uipath 2.1.36__tar.gz → 2.1.37__tar.gz

{uipath-2.1.36 → uipath-2.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.36
+Version: 2.1.37
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python
@@ -21,6 +21,7 @@ Requires-Dist: opentelemetry-instrumentation>=0.52b1
 Requires-Dist: opentelemetry-sdk>=1.31.1
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pydantic>=2.11.1
+Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tenacity>=9.0.0

{uipath-2.1.36 → uipath-2.1.37}/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"
@@ -18,6 +18,7 @@ dependencies = [
   "azure-monitor-opentelemetry>=1.6.8",
   "truststore>=0.10.1",
   "textual>=5.3.0",
+  "pyperclip>=1.9.0",
 ]
 classifiers = [
   "Development Status :: 3 - Alpha",

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/__init__.py

@@ -7,10 +7,15 @@ from pathlib import Path
 from typing import Any, Dict
 from uuid import uuid4
 
+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
+from textual.widgets import Button, Footer, Input, ListView, RichLog
+
+from uipath.agent.conversation import UiPathConversationEvent
 
 from ..._runtime._contracts import (
     UiPathErrorContract,
@@ -22,23 +27,26 @@ from ..._runtime._contracts import (
 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 = [
         Binding("q", "quit", "Quit"),
         Binding("n", "new_run", "New"),
         Binding("r", "execute_run", "Run"),
-        Binding("c", "clear_history", "Clear History"),
+        Binding("c", "copy", "Copy"),
+        Binding("h", "clear_history", "Clear History"),
         Binding("escape", "cancel", "Cancel"),
     ]
 
@@ -88,8 +96,6 @@ class UiPathDevTerminal(App[Any]):
             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."""
@@ -101,6 +107,31 @@ class UiPathDevTerminal(App[Any]):
                 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")
@@ -113,20 +144,6 @@ class UiPathDevTerminal(App[Any]):
         """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)
@@ -157,6 +174,16 @@ class UiPathDevTerminal(App[Any]):
         history_panel.clear_runs()
         await self.action_new_run()
 
+    def action_copy(self) -> None:
+        """Copy content of currently focused RichLog to clipboard and notify."""
+        focused = self.app.focused
+        if isinstance(focused, RichLog):
+            clipboard_text = "\n".join(line.text for line in focused.lines)
+            pyperclip.copy(clipboard_text)
+            self.app.notify("Copied to clipboard!", timeout=1.5)
+        else:
+            self.app.notify("Nothing to copy here.", timeout=1.5, severity="warning")
+
     async def _execute_runtime(self, run: ExecutionRun):
         """Execute the script using UiPath runtime."""
         try:
@@ -166,7 +193,10 @@ class UiPathDevTerminal(App[Any]):
                 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
                 ),
             )
 
@@ -196,17 +226,13 @@ class UiPathDevTerminal(App[Any]):
             run.end_time = datetime.now()
 
         except UiPathRuntimeError as e:
-            error_msg = (
-                f"{e.error_info.code}: {e.error_info.title}\n{e.error_info.detail}"
-            )
-            self._add_error_log(run, error_msg)
+            self._add_error_log(run)
             run.status = "failed"
             run.end_time = datetime.now()
             run.error = e.error_info
 
         except Exception as e:
-            error_msg = f"Execution failed: {str(e)}"
-            self._add_error_log(run, error_msg)
+            self._add_error_log(run)
             run.status = "failed"
             run.end_time = datetime.now()
             run.error = UiPathErrorContract(
@@ -262,14 +288,27 @@ class UiPathDevTerminal(App[Any]):
         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()
         log_msg = LogMessage(run.id, "INFO", message, timestamp)
         self._handle_log_message(log_msg)
 
-    def _add_error_log(self, run: ExecutionRun, message: str):
+    def _add_error_log(self, run: ExecutionRun):
         """Add error log to run."""
         timestamp = datetime.now()
-        log_msg = LogMessage(run.id, "ERROR", message, timestamp)
+        tb = Traceback(
+            show_locals=False,
+            max_frames=4,
+        )
+        log_msg = LogMessage(run.id, "ERROR", tb, timestamp)
         self._handle_log_message(log_msg)

uipath-2.1.37/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)

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/_components/_details.py

@@ -3,12 +3,14 @@ from typing import Dict, List, Optional
 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 @@ class RunDetailsPanel(Container):
                     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 @@ class RunDetailsPanel(Container):
         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 @@ class RunDetailsPanel(Container):
 
     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()
@@ -416,14 +418,25 @@ class RunDetailsPanel(Container):
         timestamp_str = log_msg.timestamp.strftime("%H:%M:%S")
         level_short = log_msg.level[:4].upper()
 
-        log_text = (
-            f"[dim]{timestamp_str}[/dim] "
-            f"[{color}]{level_short}[/{color}] "
-            f"{log_msg.message}"
-        )
-
         logs_log = self.query_one("#logs-log", RichLog)
-        logs_log.write(log_text)
+        if isinstance(log_msg.message, str):
+            log_text = (
+                f"[dim]{timestamp_str}[/dim] "
+                f"[{color}]{level_short}[/{color}] "
+                f"{log_msg.message}"
+            )
+            logs_log.write(log_text)
+        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."""

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/_components/_history.py

@@ -34,6 +34,10 @@ class RunHistoryPanel(Container):
                         classes="new-run-btn",
                     )
 
+    def on_mount(self) -> None:
+        # Update only running items every 5 seconds
+        self.set_interval(5.0, self._refresh_running_items)
+
     def add_run(self, run: ExecutionRun):
         """Add a new run to history."""
         self.runs.insert(0, run)  # Add to top
@@ -67,3 +71,15 @@ class RunHistoryPanel(Container):
         """Clear all runs from history."""
         self.runs.clear()
         self.refresh_list()
+
+    def _refresh_running_items(self) -> None:
+        if not any(run.status == "running" for run in self.runs):
+            return None  # No running items, skip update
+
+        run_list = self.query_one("#run-list", ListView)
+
+        for item in run_list.children:
+            run = self.get_run_by_id(item.run_id)  # type: ignore[attr-defined]
+            if run and run.status == "running":
+                static = item.query_one(Static)
+                static.update(run.display_name)

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/_models/_execution.py

@@ -5,7 +5,10 @@ from uuid import uuid4
 
 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
 
 
@@ -20,10 +23,11 @@ class ExecutionRun:
         self.output_data: Optional[Dict[str, Any]] = None
         self.start_time = datetime.now()
         self.end_time: Optional[datetime] = None
-        self.status = "running"  # running, completed, failed
+        self.status = "running"  # running, completed, failed, suspended
         self.traces: List[TraceMessage] = []
         self.logs: List[LogMessage] = []
         self.error: Optional[UiPathErrorContract] = None
+        self.chat_aggregator = ConversationAggregator()
 
     @property
     def duration(self) -> str:
@@ -53,14 +57,23 @@ class ExecutionRun:
         script_name = (
             os.path.basename(self.entrypoint) if self.entrypoint else "untitled"
         )
-        truncated_script = script_name[:10]
+        truncated_script = script_name[:8]
         time_str = self.start_time.strftime("%H:%M:%S")
         duration_str = self.duration[:6]
 
         text = Text()
         text.append(f"{status_icon:<2} ", style=status_colors.get(self.status, "white"))
-        text.append(f"{truncated_script:<10} ")
+        text.append(f"{truncated_script:<8} ")
         text.append(f"({time_str:<8}) ")
         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)

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/_models/_messages.py

@@ -1,6 +1,7 @@
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
+from rich.console import RenderableType
 from textual.message import Message
 
 
@@ -28,7 +29,7 @@ class LogMessage(Message):
         self,
         run_id: str,
         level: str,
-        message: str,
+        message: Union[str, RenderableType],
         timestamp: Optional[datetime] = None,
     ):
         self.run_id = run_id

{uipath-2.1.36 → uipath-2.1.37}/src/uipath/_cli/_dev/_terminal/_styles/terminal.tcss

@@ -64,7 +64,8 @@ Screen {
 }
 
 .run-actions {
-    height: 2;
+    dock: bottom;
+    height: auto;
     align: left middle;
 }
 
@@ -204,7 +205,7 @@ SpanDetailsDisplay {
 
 .json-input {
     margin-top: 1;
-    height: 12;
+    height: auto;
 }
 
 .run-actions {
@@ -222,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;
+}