uipath 2.1.93__py3-none-any.whl → 2.1.95__py3-none-any.whl

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/_cli/_debug/_bridge.py

@@ -0,0 +1,416 @@
+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]")
+        if state_event.payload:
+            self._print_json(state_event.payload, label="State")
+
+    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/_cli/_debug/_runtime.py

@@ -0,0 +1,134 @@
+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
+                    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
+
+                # 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/_cli/_runtime/_contracts.py

@@ -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.
 
@@ -591,7 +597,7 @@ class UiPathBaseRuntime(ABC):
             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:
@@ -607,7 +613,7 @@ class UiPathBaseRuntime(ABC):
                     # 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/_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
             )

uipath/_cli/cli_debug.py

@@ -0,0 +1,142 @@
+# type: ignore
+import asyncio
+import os
+import uuid
+from os import environ as env
+from typing import Optional
+
+import click
+
+from uipath._cli._utils._debug import setup_debugging
+from uipath.tracing import LlmOpsHttpExporter
+
+from .._utils.constants import (
+    ENV_JOB_ID,
+)
+from ..telemetry import track
+from ._debug._bridge import UiPathDebugBridge, get_debug_bridge
+from ._debug._runtime import UiPathDebugRuntime
+from ._runtime._contracts import (
+    UiPathRuntimeContext,
+    UiPathRuntimeFactory,
+)
+from ._runtime._runtime import UiPathScriptRuntime
+from ._utils._console import ConsoleLogger
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument("entrypoint", required=False)
+@click.argument("input", required=False, default="{}")
+@click.option("--resume", is_flag=True, help="Resume execution from a previous state")
+@click.option(
+    "-f",
+    "--file",
+    required=False,
+    type=click.Path(exists=True),
+    help="File path for the .json input",
+)
+@click.option(
+    "--input-file",
+    required=False,
+    type=click.Path(exists=True),
+    help="Alias for '-f/--file' arguments",
+)
+@click.option(
+    "--output-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the output will be written",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debugging with debugpy. The process will wait for a debugger to attach.",
+)
+@click.option(
+    "--debug-port",
+    type=int,
+    default=5678,
+    help="Port for the debug server (default: 5678)",
+)
+@track(when=lambda *_a, **_kw: env.get(ENV_JOB_ID) is None)
+def debug(
+    entrypoint: Optional[str],
+    input: Optional[str],
+    resume: bool,
+    file: Optional[str],
+    input_file: Optional[str],
+    output_file: Optional[str],
+    debug: bool,
+    debug_port: int,
+) -> None:
+    """Execute the project."""
+    input_file = file or input_file
+    # Setup debugging if requested
+    if not setup_debugging(debug, debug_port):
+        console.error(f"Failed to start debug server on port {debug_port}")
+
+    result = Middlewares.next(
+        "debug",
+        entrypoint,
+        input,
+        resume,
+        input_file=input_file,
+        execution_output_file=output_file,
+        debug=debug,
+        debug_port=debug_port,
+    )
+
+    if result.error_message:
+        console.error(result.error_message)
+
+    if result.should_continue:
+        if not entrypoint:
+            console.error("""No entrypoint specified. Please provide a path to a Python script.
+    Usage: `uipath debug <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""")
+
+        if not os.path.exists(entrypoint):
+            console.error(f"""Script not found at path {entrypoint}.
+    Usage: `uipath debug <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""")
+
+        try:
+            debug_context = UiPathRuntimeContext.with_defaults(
+                entrypoint=entrypoint,
+                input=input,
+                input_file=input_file,
+                resume=resume,
+                execution_output_file=output_file,
+                debug=debug,
+            )
+            debug_context.execution_id = debug_context.job_id or str(uuid.uuid4())
+
+            runtime_factory = UiPathRuntimeFactory(
+                UiPathScriptRuntime,
+                UiPathRuntimeContext,
+                context_generator=lambda: debug_context,
+            )
+
+            debug_bridge: UiPathDebugBridge = get_debug_bridge(debug_context)
+
+            if debug_context.job_id:
+                runtime_factory.add_span_exporter(LlmOpsHttpExporter())
+
+            async def execute():
+                async with UiPathDebugRuntime.from_debug_context(
+                    factory=runtime_factory,
+                    context=debug_context,
+                    debug_bridge=debug_bridge,
+                ) as debug_runtime:
+                    await debug_runtime.execute()
+
+            asyncio.run(execute())
+        except Exception as e:
+            console.error(
+                f"Error occurred: {e or 'Execution failed'}", include_traceback=True
+            )
+
+
+if __name__ == "__main__":
+    debug()

uipath/_cli/cli_run.py

@@ -115,7 +115,12 @@ def run(
             if context.job_id:
                 runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
-            asyncio.run(runtime_factory.execute(context))
+            async def execute_runtime():
+                result = await runtime_factory.execute(context)
+                if not context.job_id:
+                    console.info(result.output)
+
+            asyncio.run(execute_runtime())
 
         except UiPathRuntimeError as e:
             console.error(f"{e.error_info.title} - {e.error_info.detail}")

uipath/_cli/middlewares.py

@@ -31,6 +31,7 @@ class Middlewares:
         "dev": [],
         "invoke": [],
         "eval": [],
+        "debug": [],
     }
     _plugins_loaded = False
 

{uipath-2.1.93.dist-info → uipath-2.1.95.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.93
+Version: 2.1.95
 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.93.dist-info → uipath-2.1.95.dist-info}/RECORD

@@ -5,8 +5,9 @@ uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,186
 uipath/_uipath.py,sha256=mhtdu36-A-2WhPGNFFrTmQWbE07Bn4IV_Vrqgf6kuVM,4900
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
-uipath/_cli/__init__.py,sha256=9dqPdh8kgKwV-Y2Riz6411ikyKGWhKioMrqwJPQHi8w,2303
+uipath/_cli/__init__.py,sha256=RZtYzThMGEKEwmiUwwm6TUU5KxDpfTuez2qSFD78J8w,2345
 uipath/_cli/cli_auth.py,sha256=CzetSRqSUvMs02PtI4w5Vi_0fv_ETA307bB2vXalWzY,2628
+uipath/_cli/cli_debug.py,sha256=-0ZWMe3aKfVZSiZCe7U2K_Xpai1fKxZpaETu_7ewj2s,4163
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
 uipath/_cli/cli_eval.py,sha256=oOMywGSUrHDQ1W_54ccbekzCeduPf-KHRyu_r0Dezd0,5444
@@ -17,8 +18,8 @@ uipath/_cli/cli_pack.py,sha256=U5rXVbUnHFgdEsXyhkjmWza8dfob1wU9lyl4yrYnUss,11076
 uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,6471
 uipath/_cli/cli_pull.py,sha256=muX2gR-W-bSrNI3pIO0zbhZAP0VBOSsOY2-yrq8HgAw,2433
 uipath/_cli/cli_push.py,sha256=_JbjI45uJaobBDaz--NlzAXYJNwHX_XGLa8eC9wN-Cg,3166
-uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
-uipath/_cli/middlewares.py,sha256=0D9a-wphyetnH9T97F08o7-1OKWF1lMweFHHAR0xiOw,4979
+uipath/_cli/cli_run.py,sha256=dLEFu_sFOKeKN9juscFt-PKnTl4-mTF1PNP_44skG-0,3887
+uipath/_cli/middlewares.py,sha256=tb0c4sU1SCYi0PNs956Qmk24NDk0C0mBfVQmTcyORE0,5000
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=v_b8KNwn0tAv8jxpeKdllOVzl31q9AcdwpE_koAK_w4,7235
 uipath/_cli/_auth/_auth_service.py,sha256=gyOtaHnDmjYccW0R1HVmFgV69a7w53Dx1Mq-PM0uVag,5405
@@ -31,6 +32,8 @@ uipath/_cli/_auth/auth_config.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0Q
 uipath/_cli/_auth/index.html,sha256=uGK0CDTP8Rys_p4O_Pbd2x4tz0frKNVcumjrXnal5Nc,22814
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
+uipath/_cli/_debug/_bridge.py,sha256=l2k-jIyWTSEx8uvmYRvtlh72gaZBKOV0HiNbdPbqSMQ,13896
+uipath/_cli/_debug/_runtime.py,sha256=fwpxmBFAhhMjanBQaCQdI-YuvMC6vhS8SSS8pvw_PJw,4946
 uipath/_cli/_dev/_terminal/__init__.py,sha256=di_RiN9Mcp9wqyKRRqXag28vbSw8_78mCnQZNn9H-Ss,14027
 uipath/_cli/_dev/_terminal/_components/_chat.py,sha256=NLRoy49QScHiI-q0FGykkaU8ajv1d23fx7issSALcFA,4119
 uipath/_cli/_dev/_terminal/_components/_details.py,sha256=FbLYtJ56gqHV6CIrpzO_n9Sk_YNg4nzRKTSsbj-DBPQ,17257
@@ -63,11 +66,11 @@ uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=AO2BmFwA6hz3Lte-STVr7aJDPvMCqKNKa4j2jeNZ_U4,2677
 uipath/_cli/_evals/mocks/mocks.py,sha256=HY0IaSqqO8hioBB3rp5XwAjSpQE4K5hoH6oJQ-sH72I,2207
 uipath/_cli/_push/sw_file_handler.py,sha256=voZVfJeJTqkvf5aFZvxAHQ_qa7dX_Cz7wRsfhLKL9Ag,17884
-uipath/_cli/_runtime/_contracts.py,sha256=IalIJjLYxNE-0cedRPKcubuXhhVYLOWyN2axGJk6E6o,31436
+uipath/_cli/_runtime/_contracts.py,sha256=zNbBbnEPW3hzUcgAsPQSmH8SUsEME1PtJDJbjFXcsCc,31607
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
 uipath/_cli/_runtime/_logging.py,sha256=srjAi3Cy6g7b8WNHiYNjaZT4t40F3XRqquuoGd2kh4Y,14019
-uipath/_cli/_runtime/_runtime.py,sha256=P77YtxylLzpK2yz4S0tsBTVFpBSoh5lA7Gpu0SFRD5w,2379
+uipath/_cli/_runtime/_runtime.py,sha256=Gs75gZMwohO4x_TDkw_XPH_zVmKM3qCHhUj0mI2Bna4,2209
 uipath/_cli/_runtime/_script_executor.py,sha256=PjbmEbyCMofGH2F85b8RFsxdV3Tqw0kVqdWOOk2ZLlI,9687
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
 uipath/_cli/_templates/.rels.template,sha256=-fTcw7OA1AcymHr0LzBqbMAAtzZTRXLTNa_ljq087Jk,406
@@ -184,8 +187,8 @@ uipath/tracing/_utils.py,sha256=X-LFsyIxDeNOGuHPvkb6T5o9Y8ElYhr_rP3CEBJSu4s,1383
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.93.dist-info/METADATA,sha256=TbFA1C7aF3D8rpFAJ8GAjkEgQeTa8BRSn8NPVX1q3_U,6593
-uipath-2.1.93.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.93.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.93.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.93.dist-info/RECORD,,
+uipath-2.1.95.dist-info/METADATA,sha256=KzgAYNHE2yGDV2LXNYOzbhDcl41TUjRrnp1Qa6r5pgs,6625
+uipath-2.1.95.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.95.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.95.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.95.dist-info/RECORD,,