uipath 2.1.111__py3-none-any.whl → 2.1.113__py3-none-any.whl

uipath/_cli/_debug/_bridge.py

@@ -4,7 +4,7 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Literal, Optional, Set
 
 from pydantic import BaseModel
 from pysignalr.client import SignalRClient
@@ -123,7 +123,7 @@ class UiPathDebugBridge(ABC):
         pass
 
     @abstractmethod
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at.
 
         Returns:
@@ -220,7 +220,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         """Print error."""
         self.console.print()
         self.console.print("[red]─" * 40)
-        self.console.print(f"[red]✗ Error[/red] [dim]{execution_id}")
+        self.console.print("[red]✗ Error[/red]")
         self.console.print("[red]─" * 40)
 
         # Truncate very long errors
@@ -228,7 +228,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         if len(error) > 500:
             error_display = error[:500] + "\n[dim]... (truncated)"
 
-        self.console.print(f"[white]{error_display}[/white]")
+        self.console.print(f"[red]{error_display}[/red]")
         self.console.print("[red]─" * 40)
 
     async def wait_for_resume(self) -> Any:
@@ -252,21 +252,14 @@ class ConsoleDebugBridge(UiPathDebugBridge):
                 # These commands don't resume execution, loop again
                 continue
 
-            # Reset step modes if continuing
-            if command_result["command"] == DebugCommand.CONTINUE:
-                self.state.step_mode = False
-
-            if command_result["command"] == DebugCommand.QUIT:
-                raise DebuggerQuitException("User requested exit")
-
             # Commands that resume execution: CONTINUE, STEP
             self.console.print()
             return command_result
 
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at."""
         if self.state.step_mode:
-            return ["*"]  # Suspend at all nodes
+            return "*"  # Suspend at all nodes
         return list(self.state.breakpoints)  # Only suspend at breakpoints
 
     def _parse_command(self, user_input: str) -> Dict[str, Any]:
@@ -283,6 +276,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         args = parts[1:] if len(parts) > 1 else []
 
         if cmd in ["c", "continue"]:
+            self.state.step_mode = False
             return {"command": DebugCommand.CONTINUE, "args": None}
 
         elif cmd in ["s", "step"]:
@@ -318,7 +312,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
             }
 
         elif cmd in ["q", "quit", "exit"]:
-            raise KeyboardInterrupt("User requested exit")
+            raise DebuggerQuitException("User requested exit")
 
         elif cmd in ["h", "help", "?"]:
             self._print_help()
@@ -465,26 +459,75 @@ class SignalRDebugBridge(UiPathDebugBridge):
         self._client = SignalRClient(self.hub_url, headers=all_headers)
 
         # Register event handlers
-        self._client.on("ResumeExecution", self._handle_resume)
+        self._client.on("Start", self._handle_start)
+        self._client.on("Resume", self._handle_resume)
+        self._client.on("Step", self._handle_step)
+        self._client.on("AddBreakpoints", self._handle_add_breakpoints)
+        self._client.on("RemoveBreakpoints", self._handle_remove_breakpoints)
+        self._client.on("Quit", self._handle_quit)
         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())
+        self._run_task = asyncio.create_task(self._client.run())
+
+        async def cleanup_run_task() -> str:
+            error_message = (
+                "Failed to establish WebSocket connection within 10s timeout"
+            )
+
+            if self._run_task:
+                if not self._run_task.done():
+                    self._run_task.cancel()
+                try:
+                    await self._run_task
+                except asyncio.CancelledError:
+                    pass  # Expected on cancel
+                except Exception as task_error:
+                    error_msg = str(task_error).strip()
+                    error_detail = f": {error_msg}" if error_msg else ""
+                    return f"{error_message}: {type(task_error).__name__}{error_detail}"
+
+            return error_message
+
+        try:
+            # Wait for connection with timeout
+            await asyncio.wait_for(self._connected_event.wait(), timeout=10.0)
+        except asyncio.TimeoutError as e:
+            # Clean up on timeout
+            raise RuntimeError(await cleanup_run_task()) from e
+        except Exception:
+            # Clean up on any other error
+            await cleanup_run_task()
+            raise
 
-        # Wait for connection to establish
-        await asyncio.wait_for(self._connected_event.wait(), timeout=30.0)
+        # Check if run_task failed
+        if self._run_task.done():
+            exception = self._run_task.exception()
+            if exception:
+                raise exception
 
     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:
+        if not self._client:
+            return
+
+        # Cancel the run task first
+        if self._run_task and not self._run_task.done():
+            self._run_task.cancel()
+            try:
+                await self._run_task
+            except (Exception, asyncio.CancelledError):
+                pass
+
+        # Try to close the client cleanly
+        try:
+            if hasattr(self._client, "_transport"):
+                transport = self._client._transport
+                if transport and hasattr(transport, "_ws") and transport._ws:
                     await transport._ws.close()
-                except Exception as e:
-                    logger.warning(f"Error closing SignalR WebSocket: {e}")
+        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."""
@@ -541,6 +584,9 @@ class SignalRDebugBridge(UiPathDebugBridge):
         error: str,
     ) -> None:
         """Send execution error event."""
+        if not self._connected_event.is_set():
+            return
+
         logger.error(f"Execution error: {execution_id} - {error}")
         await self._send(
             "OnExecutionError",
@@ -558,24 +604,139 @@ class SignalRDebugBridge(UiPathDebugBridge):
         logger.info("Resume command received")
         return self._resume_data
 
-    def get_breakpoints(self) -> List[str]:
+    def get_breakpoints(self) -> List[str] | Literal["*"]:
         """Get nodes to suspend execution at."""
         if self.state.step_mode:
-            return ["*"]  # Suspend at all nodes
+            return "*"  # Suspend at all nodes
         return list(self.state.breakpoints)  # Only suspend at breakpoints
 
-    async def _send(self, method: str, data: Dict[str, Any]) -> None:
-        """Send message to SignalR hub."""
+    async def _send(self, event_name: str, data: Dict[str, Any]) -> None:
+        """Send message to SignalR hub via SendCommand.
+
+        Args:
+            event_name: The event/command name (e.g., "OnExecutionStarted")
+            data: The data payload to send
+        """
         if not self._client:
             raise RuntimeError("SignalR client not connected")
+        try:
+            # Wrap the event in SendCommand protocol
+            # Server expects: SendCommand(event_name, json_string_of_data)
+            data_json = json.dumps(data)
+            arguments: list[Any] = [event_name, data_json]
+            await self._client.send(method="SendCommand", arguments=arguments)
+            logger.debug(f"Sent command: {event_name} with data: {data}")
+        except Exception as e:
+            logger.error(f"Error sending command {event_name} to SignalR hub: {e}")
+
+    async def _handle_start(self, args: list[Any]) -> None:
+        """Handle Start command from SignalR server.
 
-        await self._client.send(method=method, arguments=[data])
+        Args:
+            args: List containing command arguments, typically [dict_with_args]
+        """
+        logger.info(f"Start command received with args: {args}")
+        if not args or len(args) == 0:
+            logger.warning("Start command received with empty args.")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        self.state.breakpoints = set(command_args.get("breakpoints", []))
+        step_mode = command_args.get("enableStepMode", False)
+        self.state.step_mode = step_mode
 
     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]
+        """Handle Resume command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        logger.info(f"Resume command received with args: {args}")
+        command_args = args[0] if args and len(args) > 0 else {}
+
+        if self._resume_event:
+            self._resume_data = command_args
             self._resume_event.set()
+            logger.info("Resume event set")
+        else:
+            logger.warning("Resume command received but no resume event is waiting")
+
+    async def _handle_step(self, args: list[Any]) -> None:
+        """Handle Step command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        logger.info(f"Step command received with args: {args}")
+        self.state.step_mode = True
+        logger.info("Step mode enabled")
+
+    async def _handle_add_breakpoints(self, args: list[Any]) -> None:
+        """Handle AddBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments with breakpoints list
+        """
+        logger.info(f"AddBreakpoints command received with args: {args}")
+        if not args or len(args) == 0:
+            logger.warning("AddBreakpoints command received with empty args.")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        break_points = command_args.get("breakpoints", [])
+
+        for bp in break_points:
+            node_name = (
+                bp.get("node", {}).get("name")
+                if isinstance(bp.get("node"), dict)
+                else None
+            )
+            if node_name:
+                self.state.add_breakpoint(node_name)
+                logger.info(f"Breakpoint set at: {node_name}")
+            else:
+                logger.warning(f"Breakpoint command received without node name: {bp}")
+
+    async def _handle_remove_breakpoints(self, args: list[Any]) -> None:
+        """Handle RemoveBreakpoints command from SignalR server.
+
+        Args:
+            args: List containing command arguments with breakpoints list
+        """
+        logger.info(f"RemoveBreakpoints command received with args: {args}")
+        if not args or len(args) == 0:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+            return
+
+        command_args = args[0] if isinstance(args[0], dict) else {}
+        break_points = command_args.get("breakpoints", [])
+
+        if not break_points:
+            self.state.clear_all_breakpoints()
+            logger.info("All breakpoints cleared")
+        else:
+            for bp in break_points:
+                node_name = (
+                    bp.get("node", {}).get("name")
+                    if isinstance(bp.get("node"), dict)
+                    else None
+                )
+                if node_name:
+                    self.state.remove_breakpoint(node_name)
+                    logger.info(f"Breakpoint removed: {node_name}")
+
+    async def _handle_quit(self, args: list[Any]) -> None:
+        """Handle Quit command from SignalR server.
+
+        Args:
+            args: List containing command arguments
+        """
+        if args:
+            logger.info(f"Quit command received from server with args: {args}")
+        else:
+            logger.info("Quit command received from server")
+        raise DebuggerQuitException("Quit command received from server")
 
     async def _handle_open(self) -> None:
         """Handle SignalR connection open."""

uipath/_cli/_debug/_runtime.py

@@ -35,6 +35,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
         self.context: UiPathRuntimeContext = context
         self.factory: UiPathRuntimeFactory[T, C] = factory
         self.debug_bridge: UiPathDebugBridge = debug_bridge
+        self.execution_id: str = context.job_id or "default"
         self._inner_runtime: Optional[T] = None
 
     @classmethod
@@ -57,7 +58,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
                 raise RuntimeError("Failed to create inner runtime")
 
             await self.debug_bridge.emit_execution_started(
-                execution_id=self.context.job_id or "default"
+                execution_id=self.execution_id
             )
 
             # Try to stream events from inner runtime
@@ -78,8 +79,11 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         except Exception as e:
             # Emit execution error
+            self.context.result = UiPathRuntimeResult(
+                status=UiPathRuntimeStatus.FAULTED,
+            )
             await self.debug_bridge.emit_execution_error(
-                execution_id=self.context.job_id or "default",
+                execution_id=self.execution_id,
                 error=str(e),
             )
             raise

uipath/_cli/_evals/_models/_output.py

@@ -8,7 +8,11 @@ from pydantic.alias_generators import to_camel
 from pydantic_core import core_schema
 
 from uipath._cli._runtime._contracts import UiPathRuntimeResult
-from uipath.eval.models.models import EvaluationResult, ScoreType
+from uipath.eval.models.models import (
+    EvaluationResult,
+    ScoreType,
+    TrajectoryEvaluationTrace,
+)
 
 
 class UiPathEvalRunExecutionOutput(BaseModel):
@@ -22,6 +26,22 @@ class UiPathEvalRunExecutionOutput(BaseModel):
     result: UiPathRuntimeResult
 
 
+class UiPathSerializableEvalRunExecutionOutput(BaseModel):
+    execution_time: float
+    trace: TrajectoryEvaluationTrace
+    result: UiPathRuntimeResult
+
+
+def convert_eval_execution_output_to_serializable(
+    output: UiPathEvalRunExecutionOutput,
+) -> UiPathSerializableEvalRunExecutionOutput:
+    return UiPathSerializableEvalRunExecutionOutput(
+        execution_time=output.execution_time,
+        result=output.result,
+        trace=TrajectoryEvaluationTrace.from_readable_spans(output.spans),
+    )
+
+
 class EvaluationResultDto(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
@@ -67,19 +87,13 @@ class EvaluationRunResultDto(BaseModel):
     evaluator_id: str
     result: EvaluationResultDto
 
-    @model_serializer(mode="wrap")
-    def serialize_model(self, serializer, info):
-        data = serializer(self)
-        if isinstance(data, dict):
-            data.pop("evaluatorId", None)
-        return data
-
 
 class EvaluationRunResult(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
     evaluation_name: str
     evaluation_run_results: List[EvaluationRunResultDto]
+    agent_execution_output: Optional[UiPathSerializableEvalRunExecutionOutput] = None
 
     @property
     def score(self) -> float:

uipath/_cli/_evals/_runtime.py

@@ -38,6 +38,7 @@ from .._runtime._contracts import (
 )
 from .._runtime._logging import ExecutionLogHandler
 from .._utils._eval_set import EvalHelpers
+from ..models.runtime_schema import Entrypoint
 from ._evaluator_factory import EvaluatorFactory
 from ._models._evaluation_set import (
     AnyEvaluationItem,
@@ -53,6 +54,7 @@ from ._models._output import (
     EvaluationRunResultDto,
     UiPathEvalOutput,
     UiPathEvalRunExecutionOutput,
+    convert_eval_execution_output_to_serializable,
 )
 from ._span_collection import ExecutionSpanCollector
 from .mocks.mocks import (
@@ -147,6 +149,7 @@ class UiPathEvalContext(UiPathRuntimeContext):
     workers: Optional[int] = 1
     eval_set: Optional[str] = None
     eval_ids: Optional[List[str]] = None
+    verbose: bool = False
 
 
 class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
@@ -173,6 +176,15 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         self.logs_exporter: ExecutionLogsExporter = ExecutionLogsExporter()
         self.execution_id = str(uuid.uuid4())
+        self.entrypoint: Optional[Entrypoint] = None
+
+    async def get_entrypoint(self):
+        if not self.entrypoint:
+            temp_runtime = self.factory.new_runtime(
+                entrypoint=self.context.entrypoint, runtime_dir=os.getcwd()
+            )
+            self.entrypoint = await temp_runtime.get_entrypoint()
+        return self.entrypoint
 
     @classmethod
     def from_eval_context(
@@ -187,13 +199,6 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         if self.context.eval_set is None:
             raise ValueError("eval_set must be provided for evaluation runs")
 
-        # Get entrypoint from a temporary runtime
-        temp_context = self.factory.new_context(
-            entrypoint=self.context.entrypoint, runtime_dir=os.getcwd()
-        )
-        temp_runtime = self.factory.from_context(temp_context)
-        self.entrypoint = await temp_runtime.get_entrypoint()
-
         event_bus = self.event_bus
 
         # Load eval set (path is already resolved in cli_eval.py)
@@ -360,6 +365,12 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         try:
             agent_execution_output = await self.execute_runtime(eval_item, execution_id)
+            if self.context.verbose:
+                evaluation_run_results.agent_execution_output = (
+                    convert_eval_execution_output_to_serializable(
+                        agent_execution_output
+                    )
+                )
             evaluation_item_results: list[EvalItemResult] = []
 
             for evaluator in evaluators:
@@ -477,7 +488,9 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         self, eval_item: AnyEvaluationItem
     ) -> AnyEvaluationItem:
         """Use LLM to generate a mock input for an evaluation item."""
-        generated_input = await generate_llm_input(eval_item, self.entrypoint.input)
+        generated_input = await generate_llm_input(
+            eval_item, (await self.get_entrypoint()).input
+        )
         updated_eval_item = eval_item.model_copy(update={"inputs": generated_input})
         return updated_eval_item
 

uipath/_cli/_runtime/_contracts.py

@@ -382,7 +382,7 @@ class UiPathRuntimeContext(BaseModel):
     log_handler: Optional[logging.Handler] = None
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
-    breakpoints: Optional[List[str]] = None
+    breakpoints: Optional[List[str] | Literal["*"]] = None
 
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
@@ -536,6 +536,7 @@ class UiPathRuntimeError(UiPathBaseRuntimeError):
         title: str,
         detail: str,
         category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        status: Optional[int] = None,
         prefix: str = "Python",
         include_traceback: bool = True,
     ):
@@ -544,6 +545,7 @@ class UiPathRuntimeError(UiPathBaseRuntimeError):
             title=title,
             detail=detail,
             category=category,
+            status=status,
             prefix=prefix,
             include_traceback=include_traceback,
         )

uipath/_resources/SDK_REFERENCE.md

@@ -127,19 +127,19 @@ Documents service
 # Create a validation action for a document based on the extraction response. More details about validation actions can be found in the [official documentation](https://docs.uipath.com/ixp/automation-cloud/latest/user-guide/validating-extractions).
 sdk.documents.create_validation_action(action_title: str, action_priority: <enum 'ActionPriority, action_catalog: str, action_folder: str, storage_bucket_name: str, storage_bucket_directory_path: str, extraction_response: uipath.models.documents.ExtractionResponse) -> uipath.models.documents.ValidationAction
 
-# Asynchronously create a validation action for a document based on the extraction response.
+# Asynchronous version of the [`create_validation_action`][uipath._services.documents_service.DocumentsService.create_validation_action] method.
 sdk.documents.create_validation_action_async(action_title: str, action_priority: <enum 'ActionPriority, action_catalog: str, action_folder: str, storage_bucket_name: str, storage_bucket_directory_path: str, extraction_response: uipath.models.documents.ExtractionResponse) -> uipath.models.documents.ValidationAction
 
 # Extract predicted data from a document using an IXP project.
-sdk.documents.extract(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> uipath.models.documents.ExtractionResponse
+sdk.documents.extract(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, project_type: <enum 'ProjectType="IXP", document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
 
-# Asynchronously extract predicted data from a document using an IXP project.
-sdk.documents.extract_async(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None) -> uipath.models.documents.ExtractionResponse
+# Asynchronously version of the [`extract`][uipath._services.documents_service.DocumentsService.extract] method.
+sdk.documents.extract_async(project_name: str, tag: str, file: Union[IO[bytes], bytes, str, NoneType]=None, file_path: Optional[str]=None, project_type: <enum 'ProjectType="IXP", document_type_name: Optional[str]=None) -> typing.Union[uipath.models.documents.ExtractionResponse, uipath.models.documents.ExtractionResponseIXP]
 
 # Get the result of a validation action.
 sdk.documents.get_validation_result(validation_action: uipath.models.documents.ValidationAction) -> uipath.models.documents.ValidatedResult
 
-# Asynchronously get the result of a validation action.
+# Asynchronous version of the [`get_validation_result`][uipath._services.documents_service.DocumentsService.get_validation_result] method.
 sdk.documents.get_validation_result_async(validation_action: uipath.models.documents.ValidationAction) -> uipath.models.documents.ValidatedResult
 
 ```