uipath 2.1.110__py3-none-any.whl → 2.1.112__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/_evaluation_set.py

@@ -142,6 +142,10 @@ class LegacyEvaluationItem(BaseModel):
         default=None,
         alias="mockingStrategy",
     )
+    input_mocking_strategy: Optional[InputMockingStrategy] = Field(
+        default=None,
+        alias="inputMockingStrategy",
+    )
 
 
 class EvaluationSet(BaseModel):

uipath/_cli/_evals/_runtime.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+import os
 import uuid
 from collections import defaultdict
 from pathlib import Path
@@ -186,6 +187,13 @@ 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)
@@ -330,6 +338,10 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         evaluators: List[AnyEvaluator],
         event_bus: EventBus,
     ) -> EvaluationRunResult:
+        # Generate LLM-based input if input_mocking_strategy is defined
+        if eval_item.input_mocking_strategy:
+            eval_item = await self._generate_input_for_eval(eval_item)
+
         execution_id = str(uuid.uuid4())
 
         set_execution_context(eval_item, self.span_collector, execution_id)
@@ -462,12 +474,10 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         return evaluation_run_results
 
     async def _generate_input_for_eval(
-        self, eval_item: EvaluationItem
-    ) -> EvaluationItem:
+        self, eval_item: AnyEvaluationItem
+    ) -> AnyEvaluationItem:
         """Use LLM to generate a mock input for an evaluation item."""
-        # TODO(bai): get the input schema from agent definition, once it is available there.
-        input_schema: dict[str, Any] = {}
-        generated_input = await generate_llm_input(eval_item, input_schema)
+        generated_input = await generate_llm_input(eval_item, self.entrypoint.input)
         updated_eval_item = eval_item.model_copy(update={"inputs": generated_input})
         return updated_eval_item
 

uipath/_cli/_evals/mocks/input_mocker.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from typing import Any, Dict
 
 from uipath import UiPath
-from uipath._cli._evals._models._evaluation_set import EvaluationItem
+from uipath._cli._evals._models._evaluation_set import AnyEvaluationItem
 from uipath.tracing._traced import traced
 
 from .mocker import UiPathInputMockingError
@@ -54,20 +54,30 @@ OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA i
 
 @traced(name="__mocker__")
 async def generate_llm_input(
-    evaluation_item: EvaluationItem,
+    evaluation_item: AnyEvaluationItem,
     input_schema: Dict[str, Any],
 ) -> Dict[str, Any]:
     """Generate synthetic input using an LLM based on the evaluation context."""
     try:
         llm = UiPath().llm
 
+        # Ensure additionalProperties is set for strict mode compatibility
+        if "additionalProperties" not in input_schema:
+            input_schema["additionalProperties"] = False
+
+        expected_output = (
+            getattr(evaluation_item, "evaluation_criterias", None)
+            or getattr(evaluation_item, "expected_output", None)
+            or {}
+        )
+
         prompt = get_input_mocking_prompt(
             input_schema=json.dumps(input_schema, indent=2),
             input_generation_instructions=evaluation_item.input_mocking_strategy.prompt
             if evaluation_item.input_mocking_strategy
             else "",
             expected_behavior=evaluation_item.expected_agent_behavior or "",
-            expected_output=json.dumps(evaluation_item.evaluation_criterias, indent=2),
+            expected_output=json.dumps(expected_output, indent=2),
         )
 
         response_format = {

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"}
 

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
 
 ```