uipath 2.1.92__tar.gz → 2.1.94__tar.gz

{uipath-2.1.92 → uipath-2.1.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.92
+Version: 2.1.94
 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
@@ -25,6 +25,7 @@ Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pydantic-function-models>=0.1.10
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: pyperclip>=1.9.0
+Requires-Dist: pysignalr==1.3.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tenacity>=9.0.0

{uipath-2.1.92 → uipath-2.1.94}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.92"
+version = "2.1.94"
 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"
@@ -22,6 +22,7 @@ dependencies = [
   "mockito>=1.5.4",
   "hydra-core>=1.3.2",
   "pydantic-function-models>=0.1.10",
+  "pysignalr==1.3.0",
 ]
 classifiers = [
   "Development Status :: 3 - Alpha",

{uipath-2.1.92 → uipath-2.1.94}/src/uipath/_cli/__init__.py

@@ -5,6 +5,7 @@ import click
 
 from ._utils._common import add_cwd_to_path, load_environment_variables
 from .cli_auth import auth as auth
+from .cli_debug import debug as debug  # type: ignore
 from .cli_deploy import deploy as deploy  # type: ignore
 from .cli_dev import dev as dev
 from .cli_eval import eval as eval  # type: ignore
@@ -74,4 +75,4 @@ cli.add_command(push)
 cli.add_command(pull)
 cli.add_command(eval)
 cli.add_command(dev)
-cli.add_command(run, name="debug")
+cli.add_command(debug)

uipath-2.1.94/src/uipath/_cli/_debug/_bridge.py

@@ -0,0 +1,414 @@
+import asyncio
+import json
+import logging
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from pysignalr.client import SignalRClient
+from rich.console import Console
+from rich.syntax import Syntax
+
+from uipath._cli._runtime._contracts import (
+    UiPathBreakpointResult,
+    UiPathRuntimeContext,
+    UiPathRuntimeResult,
+)
+from uipath._events._events import UiPathAgentStateEvent
+
+logger = logging.getLogger(__name__)
+
+
+class UiPathDebugBridge(ABC):
+    """Abstract interface for debug communication.
+
+    Implementations: SignalR, Console, WebSocket, etc.
+    """
+
+    @abstractmethod
+    async def connect(self) -> None:
+        """Establish connection to debugger."""
+        pass
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Close connection to debugger."""
+        pass
+
+    @abstractmethod
+    async def emit_execution_started(self, execution_id: str, **kwargs) -> None:
+        """Notify debugger that execution started."""
+        pass
+
+    @abstractmethod
+    async def emit_state_update(self, state_event: UiPathAgentStateEvent) -> None:
+        """Notify debugger of agent state update."""
+        pass
+
+    @abstractmethod
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        """Notify debugger that a breakpoint was hit."""
+        pass
+
+    @abstractmethod
+    async def emit_execution_completed(
+        self,
+        runtime_result: UiPathRuntimeResult,
+    ) -> None:
+        """Notify debugger that execution completed."""
+        pass
+
+    @abstractmethod
+    async def emit_execution_error(
+        self,
+        execution_id: str,
+        error: str,
+    ) -> None:
+        """Notify debugger that an error occurred."""
+        pass
+
+    @abstractmethod
+    async def wait_for_resume(self) -> Any:
+        """Wait for resume command from debugger."""
+        pass
+
+
+class ConsoleDebugBridge(UiPathDebugBridge):
+    """Console-based debug bridge for local development."""
+
+    def __init__(self, verbose: bool = True):
+        """Initialize console debug bridge.
+
+        Args:
+            verbose: If True, show state updates. If False, only show breakpoints.
+        """
+        self.console = Console()
+        self.verbose = verbose
+
+    async def connect(self) -> None:
+        """Connect to console debugger."""
+        self.console.print()
+        self.console.print("[bold cyan]─" * 40)
+        self.console.print("[bold cyan]Debug Mode")
+        self.console.print("[dim]Press ENTER to continue | Type 'quit' to exit")
+        self.console.print("[bold cyan]─" * 40)
+        self.console.print()
+
+    async def disconnect(self) -> None:
+        """Cleanup."""
+        self.console.print()
+        self.console.print("[dim]─" * 40)
+        self.console.print("[green]Debug session completed")
+        self.console.print("[dim]─" * 40)
+
+    async def emit_execution_started(self, execution_id: str, **kwargs) -> None:
+        """Print execution started."""
+        self.console.print("[green]▶ Started[/green] [dim]")
+        self.console.print()
+
+    async def emit_state_update(self, state_event: UiPathAgentStateEvent) -> None:
+        """Print agent state update."""
+        if not self.verbose:
+            return
+
+        self.console.print(f"[yellow]●[/yellow] [bold]{state_event.node_name}[/bold]")
+
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        """Print breakpoint info."""
+        self.console.print()
+        self.console.print("[red]─" * 40)
+        self.console.print(
+            f"[red]■ BREAKPOINT[/red] [bold]{breakpoint_result.breakpoint_node}[/bold] "
+            f"[dim]({breakpoint_result.breakpoint_type})"
+        )
+
+        if breakpoint_result.next_nodes:
+            self.console.print(f"[dim]Next: {', '.join(breakpoint_result.next_nodes)}")
+
+        self.console.print("[red]─" * 40)
+
+        # Display current state
+        if breakpoint_result.current_state:
+            self._print_json(breakpoint_result.current_state, label="State")
+
+    async def emit_execution_completed(
+        self,
+        runtime_result: "UiPathRuntimeResult",
+    ) -> None:
+        """Print completion."""
+        self.console.print()
+
+        status_upper = runtime_result.status.value.upper()
+        if status_upper == "SUCCESSFUL":
+            color = "green"
+            symbol = "✓"
+        elif status_upper == "SUSPENDED":
+            color = "yellow"
+            symbol = "■"
+        else:
+            color = "blue"
+            symbol = "●"
+
+        self.console.print(
+            f"[{color}]{symbol} Completed[/{color}] [bold]{status_upper}[/bold]"
+        )
+        if runtime_result.output:
+            self._print_json(runtime_result.output, label="Output")
+
+    async def emit_execution_error(
+        self,
+        execution_id: str,
+        error: str,
+    ) -> None:
+        """Print error."""
+        self.console.print()
+        self.console.print("[red]─" * 40)
+        self.console.print(f"[red]✗ Error[/red] [dim]{execution_id}")
+        self.console.print("[red]─" * 40)
+
+        # Truncate very long errors
+        error_display = error
+        if len(error) > 500:
+            error_display = error[:500] + "\n[dim]... (truncated)"
+
+        self.console.print(f"[white]{error_display}[/white]")
+        self.console.print("[red]─" * 40)
+
+    async def wait_for_resume(self) -> Any:
+        """Wait for user to press Enter or type commands."""
+        self.console.print()
+        self.console.print("[cyan]> [/cyan]", end="")
+
+        # Run input() in executor to not block async loop
+        loop = asyncio.get_running_loop()
+        user_input = await loop.run_in_executor(None, input)
+
+        if user_input.strip().lower() == "quit":
+            raise KeyboardInterrupt("User requested exit")
+
+        self.console.print()
+        return user_input
+
+    def _print_json(self, data: Dict[str, Any], label: str = "Data") -> None:
+        """Print JSON data in a readable format."""
+        try:
+            json_str = json.dumps(data, indent=2, default=str)
+
+            # Limit output if too large
+            is_truncated = False
+            if len(json_str) > 2000:
+                json_str = json_str[:2000] + "\n..."
+                is_truncated = True
+
+            syntax = Syntax(
+                json_str,
+                "json",
+                theme="monokai",
+                line_numbers=False,
+                background_color="default",
+            )
+
+            self.console.print()
+            truncated_text = " (truncated)" if is_truncated else ""
+            self.console.print(f"[dim]{label}{truncated_text}:")
+            self.console.print(syntax)
+            self.console.print()
+        except Exception:
+            # Fallback to simple print
+            self.console.print()
+            self.console.print(f"[dim]{label}:")
+            self.console.print(str(data))
+            self.console.print()
+
+
+class SignalRDebugBridge(UiPathDebugBridge):
+    """SignalR-based debug bridge for remote debugging.
+
+    Communicates with a SignalR hub server.
+    """
+
+    def __init__(
+        self,
+        hub_url: str,
+        access_token: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        self.hub_url = hub_url
+        self.access_token = access_token
+        self.headers = headers or {}
+        self._client: Optional[SignalRClient] = None
+        self._connected_event = asyncio.Event()
+        self._resume_event: Optional[asyncio.Event] = None
+        self._resume_data: Any = None
+
+    async def connect(self) -> None:
+        """Establish SignalR connection."""
+        all_headers = {**self.headers}
+        if self.access_token:
+            all_headers["Authorization"] = f"Bearer {self.access_token}"
+
+        self._client = SignalRClient(self.hub_url, headers=all_headers)
+
+        # Register event handlers
+        self._client.on("ResumeExecution", self._handle_resume)
+        self._client.on_open(self._handle_open)
+        self._client.on_close(self._handle_close)
+        self._client.on_error(self._handle_error)
+
+        # Start connection in background
+        asyncio.create_task(self._client.run())
+
+        # Wait for connection to establish
+        await asyncio.wait_for(self._connected_event.wait(), timeout=30.0)
+
+    async def disconnect(self) -> None:
+        """Close SignalR connection."""
+        if self._client and hasattr(self._client, "_transport"):
+            transport = self._client._transport
+            if transport and hasattr(transport, "_ws") and transport._ws:
+                try:
+                    await transport._ws.close()
+                except Exception as e:
+                    logger.warning(f"Error closing SignalR WebSocket: {e}")
+
+    async def emit_execution_started(self, execution_id: str, **kwargs) -> None:
+        """Send execution started event."""
+        logger.info(f"Execution started: {execution_id}")
+        await self._send("OnExecutionStarted", {"executionId": execution_id, **kwargs})
+
+    async def emit_state_update(self, state_event: UiPathAgentStateEvent) -> None:
+        """Send agent state update to remote debugger."""
+        logger.info(f"State update: {state_event.node_name}")
+        await self._send(
+            "OnStateUpdate",
+            {
+                "executionId": state_event.execution_id,
+                "nodeName": state_event.node_name,
+                "state": state_event.payload,
+            },
+        )
+
+    async def emit_breakpoint_hit(
+        self, breakpoint_result: UiPathBreakpointResult
+    ) -> None:
+        """Send breakpoint hit event."""
+        logger.info(
+            f"Breakpoint hit: {breakpoint_result.breakpoint_node} "
+            f"({breakpoint_result.breakpoint_type})"
+        )
+        await self._send(
+            "OnBreakpointHit",
+            {
+                "node": breakpoint_result.breakpoint_node,
+                "type": breakpoint_result.breakpoint_type,
+                "state": breakpoint_result.current_state,
+                "nextNodes": breakpoint_result.next_nodes,
+            },
+        )
+
+    async def emit_execution_completed(
+        self,
+        runtime_result: UiPathRuntimeResult,
+    ) -> None:
+        """Send execution completed event."""
+        logger.info(f"Execution completed: {runtime_result.status}")
+        await self._send(
+            "OnExecutionCompleted",
+            {
+                "status": runtime_result.status,
+            },
+        )
+
+    async def emit_execution_error(
+        self,
+        execution_id: str,
+        error: str,
+    ) -> None:
+        """Send execution error event."""
+        logger.error(f"Execution error: {execution_id} - {error}")
+        await self._send(
+            "OnExecutionError",
+            {
+                "executionId": execution_id,
+                "error": error,
+            },
+        )
+
+    async def wait_for_resume(self) -> Any:
+        """Wait for resume command from server."""
+        logger.info("Waiting for resume command...")
+        self._resume_event = asyncio.Event()
+        await self._resume_event.wait()
+        logger.info("Resume command received")
+        return self._resume_data
+
+    async def _send(self, method: str, data: Dict[str, Any]) -> None:
+        """Send message to SignalR hub."""
+        if not self._client:
+            raise RuntimeError("SignalR client not connected")
+
+        await self._client.send(method=method, arguments=[data])
+
+    async def _handle_resume(self, args: list[Any]) -> None:
+        """Handle resume command from SignalR server."""
+        if self._resume_event and len(args) > 0:
+            self._resume_data = args[0]
+            self._resume_event.set()
+
+    async def _handle_open(self) -> None:
+        """Handle SignalR connection open."""
+        logger.info("SignalR connection established")
+        self._connected_event.set()
+
+    async def _handle_close(self) -> None:
+        """Handle SignalR connection close."""
+        logger.info("SignalR connection closed")
+        self._connected_event.clear()
+
+    async def _handle_error(self, error: Any) -> None:
+        """Handle SignalR error."""
+        logger.error(f"SignalR error: {error}")
+
+
+def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugBridge:
+    """Factory to get SignalR debug bridge for remote debugging."""
+    uipath_url = os.environ.get("UIPATH_URL")
+    if not uipath_url or not context.job_id:
+        raise ValueError(
+            "UIPATH_URL and UIPATH_JOB_KEY are required for remote debugging"
+        )
+    if not context.trace_context:
+        raise ValueError("trace_context is required for remote debugging")
+
+    signalr_url = uipath_url + "/agenthub_/wsstunnel?jobId=" + context.job_id
+    return SignalRDebugBridge(
+        hub_url=signalr_url,
+        access_token=os.environ.get("UIPATH_ACCESS_TOKEN"),
+        headers={
+            "X-UiPath-Internal-TenantId": context.trace_context.tenant_id or "",
+            "X-UiPath-Internal-AccountId": context.trace_context.org_id or "",
+            "X-UiPath-FolderKey": context.trace_context.folder_key or "",
+        },
+    )
+
+
+def get_debug_bridge(
+    context: UiPathRuntimeContext, verbose: bool = True
+) -> UiPathDebugBridge:
+    """Factory to get appropriate debug bridge based on context.
+
+    Args:
+        context: The runtime context containing debug configuration.
+        verbose: If True, console bridge shows all state updates. If False, only breakpoints.
+
+    Returns:
+        An instance of UiPathDebugBridge suitable for the context.
+    """
+    if context.job_id:
+        return get_remote_debug_bridge(context)
+    else:
+        return ConsoleDebugBridge(verbose=verbose)

uipath-2.1.94/src/uipath/_cli/_debug/_runtime.py

@@ -0,0 +1,138 @@
+import logging
+from typing import Generic, Optional, TypeVar
+
+from uipath._events._events import (
+    UiPathAgentStateEvent,
+)
+
+from .._runtime._contracts import (
+    UiPathBaseRuntime,
+    UiPathBreakpointResult,
+    UiPathRuntimeContext,
+    UiPathRuntimeFactory,
+    UiPathRuntimeResult,
+    UiPathRuntimeStreamNotSupportedError,
+)
+from ._bridge import UiPathDebugBridge
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=UiPathBaseRuntime)
+C = TypeVar("C", bound=UiPathRuntimeContext)
+
+
+class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
+    """Specialized runtime for debug runs that streams events to a debug bridge."""
+
+    def __init__(
+        self,
+        context: UiPathRuntimeContext,
+        factory: UiPathRuntimeFactory[T, C],
+        debug_bridge: UiPathDebugBridge,
+    ):
+        super().__init__(context)
+        self.context: UiPathRuntimeContext = context
+        self.factory: UiPathRuntimeFactory[T, C] = factory
+        self.debug_bridge: UiPathDebugBridge = debug_bridge
+        self._inner_runtime: Optional[T] = None
+
+    @classmethod
+    def from_debug_context(
+        cls,
+        context: UiPathRuntimeContext,
+        factory: UiPathRuntimeFactory[T, C],
+        debug_bridge: UiPathDebugBridge,
+    ) -> "UiPathDebugRuntime[T, C]":
+        return cls(context, factory, debug_bridge)
+
+    async def execute(self) -> Optional[UiPathRuntimeResult]:
+        """Execute the workflow with debug support."""
+        try:
+            await self.debug_bridge.connect()
+
+            self._inner_runtime = self.factory.new_runtime()
+
+            if not self._inner_runtime:
+                raise RuntimeError("Failed to create inner runtime")
+
+            await self.debug_bridge.emit_execution_started(
+                execution_id=self.context.execution_id or "default"
+            )
+
+            # Try to stream events from inner runtime
+            try:
+                self.context.result = await self._stream_and_debug()
+            except UiPathRuntimeStreamNotSupportedError:
+                # Fallback to regular execute if streaming not supported
+                logger.debug(
+                    f"Runtime {self._inner_runtime.__class__.__name__} does not support "
+                    "streaming, falling back to execute()"
+                )
+                self.context.result = await self._inner_runtime.execute()
+
+            if self.context.result:
+                await self.debug_bridge.emit_execution_completed(self.context.result)
+
+            return self.context.result
+
+        except Exception as e:
+            # Emit execution error
+            await self.debug_bridge.emit_execution_error(
+                execution_id=self.context.execution_id or "default",
+                error=str(e),
+            )
+            raise
+
+    async def _stream_and_debug(self) -> Optional[UiPathRuntimeResult]:
+        """Stream events from inner runtime and handle debug interactions."""
+        if not self._inner_runtime:
+            return None
+
+        final_result: Optional[UiPathRuntimeResult] = None
+        execution_completed = False
+
+        # Keep streaming until execution completes (not just paused at breakpoint)
+        while not execution_completed:
+            # Stream events from inner runtime
+            async for event in self._inner_runtime.stream():
+                # Handle final result
+                if isinstance(event, UiPathRuntimeResult):
+                    final_result = event
+
+                    # Check if it's a breakpoint result
+                    if isinstance(event, UiPathBreakpointResult):
+                        # Hit a breakpoint - wait for resume and continue
+                        await self.debug_bridge.emit_breakpoint_hit(event)
+                        await self.debug_bridge.wait_for_resume()
+                        self._inner_runtime.context.resume = True
+                        # Break out of stream loop to restart streaming from resume point
+                        break
+                    else:
+                        # Normal completion or suspension with dynamic interrupt
+                        execution_completed = True
+
+                        # Handle dynamic interrupts if present
+                        # Maybe poll for resume trigger completion here in future
+                        break
+
+                # Handle state update events - send to debug bridge
+                elif isinstance(event, UiPathAgentStateEvent):
+                    await self.debug_bridge.emit_state_update(event)
+
+        return final_result
+
+    async def validate(self) -> None:
+        """Validate runtime configuration."""
+        if self._inner_runtime:
+            await self._inner_runtime.validate()
+
+    async def cleanup(self) -> None:
+        """Cleanup runtime resources."""
+        try:
+            if self._inner_runtime:
+                await self._inner_runtime.cleanup()
+        finally:
+            try:
+                await self.debug_bridge.disconnect()
+            except Exception as e:
+                logger.warning(f"Error disconnecting debug bridge: {e}")

{uipath-2.1.92 → uipath-2.1.94}/src/uipath/_cli/_runtime/_contracts.py

@@ -35,7 +35,7 @@ from opentelemetry.sdk.trace.export import (
 from opentelemetry.trace import Tracer
 from pydantic import BaseModel, Field
 
-from uipath._events._events import BaseEvent
+from uipath._events._events import UiPathRuntimeEvent
 from uipath.agent.conversation import UiPathConversationEvent, UiPathConversationMessage
 from uipath.tracing import TracingManager
 
@@ -156,7 +156,7 @@ class UiPathRuntimeResult(BaseModel):
         return result
 
 
-class UiPathRuntimeBreakpointResult(UiPathRuntimeResult):
+class UiPathBreakpointResult(UiPathRuntimeResult):
     """Result for execution suspended at a breakpoint."""
 
     # Force status to always be SUSPENDED
@@ -488,6 +488,12 @@ class UiPathRuntimeError(Exception):
         return self.error_info.model_dump()
 
 
+class UiPathRuntimeStreamNotSupportedError(NotImplementedError):
+    """Raised when a runtime does not support streaming."""
+
+    pass
+
+
 class UiPathBaseRuntime(ABC):
     """Base runtime class implementing the async context manager protocol.
 
@@ -576,7 +582,7 @@ class UiPathBaseRuntime(ABC):
 
     async def stream(
         self,
-    ) -> AsyncGenerator[Union[BaseEvent, UiPathRuntimeResult], None]:
+    ) -> AsyncGenerator[Union[UiPathRuntimeEvent, UiPathRuntimeResult], None]:
         """Stream execution events in real-time.
 
         This is an optional method that runtimes can implement to support streaming.
@@ -586,12 +592,12 @@ class UiPathBaseRuntime(ABC):
         with the final event being UiPathRuntimeResult.
 
         Yields:
-            BaseEvent subclasses: Framework-agnostic events (MessageCreatedEvent,
-                                  AgentStateUpdatedEvent, etc.)
-            Final yield: UiPathRuntimeResult
+            UiPathRuntimeEvent subclasses: Framework-agnostic events (UiPathAgentMessageEvent,
+                                  UiPathAgentStateEvent, etc.)
+            Final yield: UiPathRuntimeResult (or its subclass UiPathBreakpointResult)
 
         Raises:
-            NotImplementedError: If the runtime doesn't support streaming
+            UiPathRuntimeStreamNotSupportedError: If the runtime doesn't support streaming
             RuntimeError: If execution fails
 
         Example:
@@ -600,14 +606,14 @@ class UiPathBaseRuntime(ABC):
                     # Last event - execution complete
                     print(f"Status: {event.status}")
                     break
-                elif isinstance(event, MessageCreatedEvent):
+                elif isinstance(event, UiPathAgentMessageEvent):
                     # Handle message event
                     print(f"Message: {event.payload}")
-                elif isinstance(event, AgentStateUpdatedEvent):
+                elif isinstance(event, UiPathAgentStateEvent):
                     # Handle state update
                     print(f"State updated by: {event.node_name}")
         """
-        raise NotImplementedError(
+        raise UiPathRuntimeStreamNotSupportedError(
             f"{self.__class__.__name__} does not implement streaming. "
             "Use execute() instead."
         )

{uipath-2.1.92 → uipath-2.1.94}/src/uipath/_cli/_runtime/_runtime.py

@@ -45,11 +45,6 @@ class UiPathRuntime(UiPathBaseRuntime):
         try:
             script_result = await self.executor(self.context.input_json)
 
-            if self.context.job_id is None and not getattr(
-                self.context, "is_eval_run", False
-            ):
-                logger.info(script_result)
-
             self.context.result = UiPathRuntimeResult(
                 output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
             )