uipath 2.1.44__py3-none-any.whl → 2.1.45__py3-none-any.whl

uipath/_cli/_evals/_runtime.py

@@ -1,4 +1,3 @@
-import copy
 from collections import defaultdict
 from time import time
 from typing import Dict, Generic, List, Optional, Sequence, TypeVar
@@ -6,8 +5,6 @@ from typing import Dict, Generic, List, Optional, Sequence, TypeVar
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
-from uipath.eval._helpers import auto_discover_entrypoint
-
 from .._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathRuntimeContext,
@@ -54,49 +51,21 @@ class ExecutionSpanExporter(SpanExporter):
         self.clear()
 
 
-class UiPathEvalContext(UiPathRuntimeContext, Generic[C]):
+class UiPathEvalContext(UiPathRuntimeContext):
     """Context used for evaluation runs."""
 
-    runtime_context: C
-    no_report: bool
-    workers: int
+    no_report: Optional[bool] = False
+    workers: Optional[int] = 1
     eval_set: Optional[str] = None
     eval_ids: Optional[List[str]] = None
 
-    def __init__(
-        self,
-        runtime_context: C,
-        no_report: bool,
-        workers: int,
-        eval_set: Optional[str] = None,
-        eval_ids: Optional[List[str]] = None,
-        **kwargs,
-    ):
-        super().__init__(
-            runtime_context=runtime_context,  # type: ignore
-            no_report=no_report,
-            workers=workers,
-            eval_set=eval_set,
-            eval_ids=eval_ids,
-            **kwargs,
-        )
-        self._auto_discover()
-
-    def _auto_discover(self):
-        self.runtime_context.entrypoint = (
-            self.runtime_context.entrypoint or auto_discover_entrypoint()
-        )
-        self.eval_set = self.eval_set or EvalHelpers.auto_discover_eval_set()
-
 
 class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     """Specialized runtime for evaluation runs, with access to the factory."""
 
-    def __init__(
-        self, context: "UiPathEvalContext[C]", factory: "UiPathRuntimeFactory[T, C]"
-    ):
+    def __init__(self, context: UiPathEvalContext, factory: UiPathRuntimeFactory[T, C]):
         super().__init__(context)
-        self.context: "UiPathEvalContext[C]" = context
+        self.context: UiPathEvalContext = context
         self.factory: UiPathRuntimeFactory[T, C] = factory
         self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
         self.factory.add_span_exporter(self.span_exporter)
@@ -104,8 +73,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     @classmethod
     def from_eval_context(
         cls,
-        context: "UiPathEvalContext[C]",
-        factory: "UiPathRuntimeFactory[T, C]",
+        context: UiPathEvalContext,
+        factory: UiPathRuntimeFactory[T, C],
     ) -> "UiPathEvalRuntime[T, C]":
         return cls(context, factory)
 
@@ -119,30 +88,26 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         )
         execution_output_list: list[UiPathEvalRunExecutionOutput] = []
         for eval_item in evaluation_set.evaluations:
-            execution_output_list.append(await self.execute_agent(eval_item))
+            execution_output = await self.execute_runtime(eval_item)
+            execution_output_list.append(execution_output)
 
         self.context.result = UiPathRuntimeResult(
             output={
                 "results": execution_output_list,
             },
             status=UiPathRuntimeStatus.SUCCESSFUL,
-            resume=None,
         )
 
-        return self.context.runtime_context.result
-
-    def _prepare_new_runtime_context(self, eval_item: EvaluationItem) -> C:
-        runtime_context = copy.deepcopy(self.context.runtime_context)
-        runtime_context.execution_id = eval_item.id
-        runtime_context.input_json = eval_item.inputs
-        # here we can pass other values from eval_item: expectedAgentBehavior, simulationInstructions etc.
-        return runtime_context
+        return self.context.result
 
-    # TODO: this would most likely need to be ported to a public AgentEvaluator class
-    async def execute_agent(
+    async def execute_runtime(
         self, eval_item: EvaluationItem
-    ) -> "UiPathEvalRunExecutionOutput":
-        runtime_context = self._prepare_new_runtime_context(eval_item)
+    ) -> UiPathEvalRunExecutionOutput:
+        runtime_context: C = self.factory.new_context(
+            execution_id=eval_item.id,
+            input_json=eval_item.inputs,
+            is_eval_run=True,
+        )
         start_time = time()
         result = await self.factory.execute_in_root_span(
             runtime_context, root_span=eval_item.name

uipath/_cli/_runtime/_contracts.py

@@ -30,6 +30,9 @@ from ._logging import LogsInterceptor
 
 logger = logging.getLogger(__name__)
 
+T = TypeVar("T", bound="UiPathBaseRuntime")
+C = TypeVar("C", bound="UiPathRuntimeContext")
+
 
 class UiPathResumeTriggerType(str, Enum):
     """Constants representing different types of resume job triggers in the system."""
@@ -315,21 +318,43 @@ class UiPathRuntimeContext(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
     @classmethod
-    def from_config(cls, config_path=None, **kwargs):
-        """Load configuration from uipath.json file.
+    def with_defaults(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:
+        """Construct a context with defaults, reading env vars and config file."""
+        resolved_config_path = config_path or os.environ.get(
+            "UIPATH_CONFIG_PATH", "uipath.json"
+        )
 
-        Args:
-            config_path: Path to the configuration file. If None, uses the default "uipath.json"
-            **kwargs: Additional keyword arguments to use as fallback for configuration values
+        base = cls.from_config(resolved_config_path)
+
+        # Apply defaults from env
+        base.job_id = os.environ.get("UIPATH_JOB_KEY")
+        base.trace_id = os.environ.get("UIPATH_TRACE_ID")
+        base.tracing_enabled = os.environ.get("UIPATH_TRACING_ENABLED", True)
+        base.logs_min_level = os.environ.get("LOG_LEVEL", "INFO")
+
+        base.trace_context = UiPathTraceContext(
+            trace_id=os.environ.get("UIPATH_TRACE_ID"),
+            parent_span_id=os.environ.get("UIPATH_PARENT_SPAN_ID"),
+            root_span_id=os.environ.get("UIPATH_ROOT_SPAN_ID"),
+            enabled=os.environ.get("UIPATH_TRACING_ENABLED", True),
+            job_id=os.environ.get("UIPATH_JOB_KEY"),
+            org_id=os.environ.get("UIPATH_ORGANIZATION_ID"),
+            tenant_id=os.environ.get("UIPATH_TENANT_ID"),
+            process_key=os.environ.get("UIPATH_PROCESS_UUID"),
+            folder_key=os.environ.get("UIPATH_FOLDER_KEY"),
+            reference_id=os.environ.get("UIPATH_JOB_KEY") or str(uuid4()),
+        )
 
-        Returns:
-            An instance of the class with fields populated from the config file
-        """
-        import json
-        import os
+        # Override with kwargs
+        for k, v in kwargs.items():
+            setattr(base, k, v)
 
-        path = config_path or "uipath.json"
+        return base
 
+    @classmethod
+    def from_config(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:
+        """Load configuration from uipath.json file."""
+        path = config_path or "uipath.json"
         config = {}
 
         if os.path.exists(path):
@@ -346,7 +371,6 @@ class UiPathRuntimeContext(BaseModel):
         }
 
         attributes_set = set()
-        # set values from config file if available
         if "runtime" in config:
             runtime_config = config["runtime"]
             for config_key, attr_name in mapping.items():
@@ -354,10 +378,8 @@ class UiPathRuntimeContext(BaseModel):
                     attributes_set.add(attr_name)
                     setattr(instance, attr_name, runtime_config[config_key])
 
-        # fallback to kwargs for any values not set from config file
         for _, attr_name in mapping.items():
             if attr_name in kwargs and hasattr(instance, attr_name):
-                # Only set from kwargs if not already set from config file
                 if attr_name not in attributes_set:
                     setattr(instance, attr_name, kwargs[attr_name])
 
@@ -383,7 +405,7 @@ class UiPathRuntimeError(Exception):
             if (
                 tb and tb.strip() != "NoneType: None"
             ):  # Ensure there's an actual traceback
-                detail = f"{detail}\n\nTraceback:\n{tb}"
+                detail = f"{detail}\n\n{tb}"
 
         if status is None:
             status = self._extract_http_status()
@@ -473,6 +495,21 @@ class UiPathBaseRuntime(ABC):
             with open(self.context.input_file) as f:
                 self.context.input = f.read()
 
+        try:
+            if self.context.input:
+                self.context.input_json = json.loads(self.context.input)
+            if self.context.input_json is None:
+                self.context.input_json = {}
+        except json.JSONDecodeError as e:
+            raise UiPathRuntimeError(
+                "INPUT_INVALID_JSON",
+                "Invalid JSON input",
+                f"The input data is not valid JSON: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+        await self.validate()
+
         # Intercept all stdout/stderr/logs and write them to a file (runtime/evals), stdout (debug)
         self.logs_interceptor = LogsInterceptor(
             min_level=self.context.logs_min_level,
@@ -620,14 +657,16 @@ class UiPathBaseRuntime(ABC):
         return os.path.join("__uipath", "state.db")
 
 
-T = TypeVar("T", bound=UiPathBaseRuntime)
-C = TypeVar("C", bound=UiPathRuntimeContext)
-
-
 class UiPathRuntimeFactory(Generic[T, C]):
     """Generic factory for UiPath runtime classes."""
 
-    def __init__(self, runtime_class: Type[T], context_class: Type[C]):
+    def __init__(
+        self,
+        runtime_class: Type[T],
+        context_class: Type[C],
+        runtime_generator: Optional[Callable[[C], T]] = None,
+        context_generator: Optional[Callable[..., C]] = None,
+    ):
         if not issubclass(runtime_class, UiPathBaseRuntime):
             raise TypeError(
                 f"runtime_class {runtime_class.__name__} must inherit from UiPathBaseRuntime"
@@ -640,10 +679,11 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
         self.runtime_class = runtime_class
         self.context_class = context_class
+        self.runtime_generator = runtime_generator
+        self.context_generator = context_generator
         self.tracer_provider: TracerProvider = TracerProvider()
         self.tracer_span_processors: List[SpanProcessor] = []
         trace.set_tracer_provider(self.tracer_provider)
-
         if os.getenv("UIPATH_JOB_KEY"):
             self.add_span_exporter(LlmOpsHttpExporter())
 
@@ -674,36 +714,49 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
     def new_context(self, **kwargs) -> C:
         """Create a new context instance."""
+        if self.context_generator:
+            return self.context_generator(**kwargs)
         return self.context_class(**kwargs)
 
+    def new_runtime(self) -> T:
+        """Create a new runtime instance."""
+        context = self.new_context()
+        if self.runtime_generator:
+            return self.runtime_generator(context)
+        return self.runtime_class.from_context(context)
+
     def from_context(self, context: C) -> T:
         """Create runtime instance from context."""
+        if self.runtime_generator:
+            return self.runtime_generator(context)
         return self.runtime_class.from_context(context)
 
     async def execute(self, context: C) -> Optional[UiPathRuntimeResult]:
         """Execute runtime with context."""
         async with self.from_context(context) as runtime:
-            result = await runtime.execute()
-            for span_processor in self.tracer_span_processors:
-                span_processor.force_flush()
-            return result
+            try:
+                return await runtime.execute()
+            finally:
+                for span_processor in self.tracer_span_processors:
+                    span_processor.force_flush()
 
     async def execute_in_root_span(
         self, context: C, root_span: str = "root"
     ) -> Optional[UiPathRuntimeResult]:
         """Execute runtime with context."""
         async with self.from_context(context) as runtime:
-            tracer: Tracer = trace.get_tracer("uipath-runtime")
-            with tracer.start_as_current_span(
-                root_span,
-                attributes={"execution.id": context.execution_id}
-                if context.execution_id
-                else {},
-            ):
-                result = await runtime.execute()
-            for span_processor in self.tracer_span_processors:
-                span_processor.force_flush()
-            return result
+            try:
+                tracer: Tracer = trace.get_tracer("uipath-runtime")
+                with tracer.start_as_current_span(
+                    root_span,
+                    attributes={"execution.id": context.execution_id}
+                    if context.execution_id
+                    else {},
+                ):
+                    return await runtime.execute()
+            finally:
+                for span_processor in self.tracer_span_processors:
+                    span_processor.force_flush()
 
 
 class UiPathExecutionTraceProcessorMixin:

uipath/_cli/_runtime/_runtime.py

@@ -1,30 +1,37 @@
 """Python script runtime implementation for executing and managing python scripts."""
 
-import importlib.util
-import inspect
-import json
 import logging
-import os
-from dataclasses import asdict, is_dataclass
-from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
-
-from pydantic import BaseModel
+from typing import Any, Awaitable, Callable, Optional, TypeVar
 
 from ._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
+    UiPathRuntimeContext,
     UiPathRuntimeError,
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
+from ._script_executor import ScriptExecutor
 
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
+R = TypeVar("R")
+AsyncFunc = Callable[[T], Awaitable[R]]
 
 
 class UiPathRuntime(UiPathBaseRuntime):
-    """Runtime for executing Python scripts."""
+    def __init__(self, context: UiPathRuntimeContext, executor: AsyncFunc[Any, Any]):
+        self.context = context
+        self.executor = executor
+
+    async def cleanup(self) -> None:
+        """Cleanup runtime resources."""
+        pass
+
+    async def validate(self):
+        """Validate runtime context."""
+        pass
 
     async def execute(self) -> Optional[UiPathRuntimeResult]:
         """Execute the Python script with the provided input and configuration.
@@ -35,15 +42,8 @@ class UiPathRuntime(UiPathBaseRuntime):
         Raises:
             UiPathRuntimeError: If execution fails
         """
-        await self.validate()
-
         try:
-            if self.context.entrypoint is None:
-                return None
-
-            script_result = await self._execute_python_script(
-                self.context.entrypoint, self.context.input_json
-            )
+            script_result = await self.executor(self.context.input_json)
 
             if self.context.job_id is None:
                 logger.info(script_result)
@@ -65,248 +65,15 @@ class UiPathRuntime(UiPathBaseRuntime):
                 UiPathErrorCategory.SYSTEM,
             ) from e
 
-    async def validate(self) -> None:
-        """Validate runtime inputs."""
-        if not self.context.entrypoint:
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_MISSING",
-                "No entrypoint specified",
-                "Please provide a path to a Python script.",
-                UiPathErrorCategory.USER,
-            )
-
-        if not os.path.exists(self.context.entrypoint):
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_NOT_FOUND",
-                "Script not found",
-                f"Script not found at path {self.context.entrypoint}.",
-                UiPathErrorCategory.USER,
-            )
-
-        try:
-            if self.context.input:
-                self.context.input_json = json.loads(self.context.input)
-            if self.context.input_json is None:
-                self.context.input_json = {}
-        except json.JSONDecodeError as e:
-            raise UiPathRuntimeError(
-                "INPUT_INVALID_JSON",
-                "Invalid JSON input",
-                f"The input data is not valid JSON: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-    async def cleanup(self) -> None:
-        """Cleanup runtime resources."""
-        pass
-
-    async def _execute_python_script(self, script_path: str, input_data: Any) -> Any:
-        """Execute the Python script with the given input."""
-        spec = importlib.util.spec_from_file_location("dynamic_module", script_path)
-        if not spec or not spec.loader:
-            raise UiPathRuntimeError(
-                "IMPORT_ERROR",
-                "Module import failed",
-                f"Could not load spec for {script_path}",
-                UiPathErrorCategory.USER,
-            )
-
-        module = importlib.util.module_from_spec(spec)
-        try:
-            spec.loader.exec_module(module)
-        except Exception as e:
-            raise UiPathRuntimeError(
-                "MODULE_EXECUTION_ERROR",
-                "Module execution failed",
-                f"Error executing module: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-        for func_name in ["main", "run", "execute"]:
-            if hasattr(module, func_name):
-                main_func = getattr(module, func_name)
-                sig = inspect.signature(main_func)
-                params = list(sig.parameters.values())
-
-                # Check if the function is asynchronous
-                is_async = inspect.iscoroutinefunction(main_func)
-
-                # Case 1: No parameters
-                if not params:
-                    try:
-                        result = await main_func() if is_async else main_func()
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                input_param = params[0]
-                input_type = input_param.annotation
-
-                # Case 2: Class, dataclass, or Pydantic model parameter
-                if input_type != inspect.Parameter.empty and (
-                    is_dataclass(input_type)
-                    or self._is_pydantic_model(input_type)
-                    or hasattr(input_type, "__annotations__")
-                ):
-                    try:
-                        valid_type = cast(Type[Any], input_type)
-                        typed_input = self._convert_to_class(input_data, valid_type)
-                        result = (
-                            await main_func(typed_input)
-                            if is_async
-                            else main_func(typed_input)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with typed input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                # Case 3: Dict parameter
-                else:
-                    try:
-                        result = (
-                            await main_func(input_data)
-                            if is_async
-                            else main_func(input_data)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with dictionary input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-        raise UiPathRuntimeError(
-            "ENTRYPOINT_FUNCTION_MISSING",
-            "No entry function found",
-            f"No main function (main, run, or execute) found in {script_path}",
-            UiPathErrorCategory.USER,
-        )
-
-    def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
-        """Convert a dictionary to either a dataclass, Pydantic model, or regular class instance."""
-        # Handle Pydantic models
-        try:
-            if inspect.isclass(cls) and issubclass(cls, BaseModel):
-                return cls.model_validate(data)
-        except TypeError:
-            # issubclass can raise TypeError if cls is not a class
-            pass
-
-        # Handle dataclasses
-        if is_dataclass(cls):
-            field_types = get_type_hints(cls)
-            converted_data = {}
 
-            for field_name, field_type in field_types.items():
-                if field_name not in data:
-                    continue
-
-                value = data[field_name]
-                if (
-                    is_dataclass(field_type)
-                    or self._is_pydantic_model(field_type)
-                    or hasattr(field_type, "__annotations__")
-                ) and isinstance(value, dict):
-                    typed_field = cast(Type[Any], field_type)
-                    value = self._convert_to_class(value, typed_field)
-                converted_data[field_name] = value
-
-            return cls(**converted_data)
-
-        # Handle regular classes
-        else:
-            sig = inspect.signature(cls.__init__)
-            params = sig.parameters
-
-            init_args = {}
-
-            for param_name, param in params.items():
-                if param_name == "self":
-                    continue
-
-                if param_name in data:
-                    value = data[param_name]
-                    param_type = (
-                        param.annotation
-                        if param.annotation != inspect.Parameter.empty
-                        else Any
-                    )
-
-                    if (
-                        is_dataclass(param_type)
-                        or self._is_pydantic_model(param_type)
-                        or hasattr(param_type, "__annotations__")
-                    ) and isinstance(value, dict):
-                        typed_param = cast(Type[Any], param_type)
-                        value = self._convert_to_class(value, typed_param)
-
-                    init_args[param_name] = value
-                elif param.default != inspect.Parameter.empty:
-                    init_args[param_name] = param.default
-
-            return cls(**init_args)
-
-    def _is_pydantic_model(self, cls: Type[Any]) -> bool:
-        """Safely check if a class is a Pydantic model."""
-        try:
-            return inspect.isclass(cls) and issubclass(cls, BaseModel)
-        except TypeError:
-            # issubclass can raise TypeError if cls is not a class
-            return False
-
-    def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
-        """Convert a class instance (dataclass, Pydantic model, or regular) to a dictionary."""
-        if obj is None:
-            return {}
-
-        # Handle Pydantic models
-        if isinstance(obj, BaseModel):
-            return obj.model_dump()
+class UiPathScriptRuntime(UiPathRuntime):
+    """Runtime for executing Python scripts."""
 
-        # Handle dataclasses
-        elif is_dataclass(obj):
-            # Make sure obj is an instance, not a class
-            if isinstance(obj, type):
-                return {}
-            return asdict(obj)
+    def __init__(self, context: UiPathRuntimeContext, entrypoint: str):
+        executor = ScriptExecutor(entrypoint)
+        super().__init__(context, executor)
 
-        # Handle regular classes
-        elif hasattr(obj, "__dict__"):
-            result = {}
-            for key, value in obj.__dict__.items():
-                # Skip private attributes
-                if not key.startswith("_"):
-                    if (
-                        isinstance(value, BaseModel)
-                        or hasattr(value, "__dict__")
-                        or is_dataclass(value)
-                    ):
-                        result[key] = self._convert_from_class(value)
-                    else:
-                        result[key] = value
-            return result
-        return {} if obj is None else {str(type(obj).__name__): str(obj)}  # Fallback
+    @classmethod
+    def from_context(cls, context: UiPathRuntimeContext):
+        """Create runtime instance from context."""
+        return UiPathScriptRuntime(context, context.entrypoint or "")

uipath/_cli/_runtime/_script_executor.py

@@ -0,0 +1,254 @@
+"""Python script runtime implementation for executing and managing python scripts."""
+
+import importlib.util
+import inspect
+import os
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Type, TypeVar, cast, get_type_hints
+
+from pydantic import BaseModel
+
+from ._contracts import (
+    UiPathErrorCategory,
+    UiPathRuntimeError,
+)
+
+T = TypeVar("T")
+
+
+class ScriptExecutor:
+    def __init__(self, entrypoint: str):
+        self.entrypoint = entrypoint
+        self.validate_entrypoint()
+
+    async def __call__(self, input: Any) -> Any:
+        return await self._execute_python_script(input)
+
+    def validate_entrypoint(self) -> None:
+        """Validate runtime inputs."""
+        if not self.entrypoint:
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_MISSING",
+                "No entrypoint specified",
+                "Please provide a path to a Python script.",
+                UiPathErrorCategory.USER,
+            )
+
+        if not os.path.exists(self.entrypoint):
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_NOT_FOUND",
+                "Script not found",
+                f"Script not found at path {self.entrypoint}.",
+                UiPathErrorCategory.USER,
+            )
+
+    async def _execute_python_script(self, input_data: Any) -> Any:
+        """Execute the Python script with the given input."""
+        spec = importlib.util.spec_from_file_location("dynamic_module", self.entrypoint)
+        if not spec or not spec.loader:
+            raise UiPathRuntimeError(
+                "IMPORT_ERROR",
+                "Module import failed",
+                f"Could not load spec for {self.entrypoint}",
+                UiPathErrorCategory.USER,
+            )
+
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise UiPathRuntimeError(
+                "MODULE_EXECUTION_ERROR",
+                "Module execution failed",
+                f"Error executing module: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+        for func_name in ["main", "run", "execute"]:
+            if hasattr(module, func_name):
+                main_func = getattr(module, func_name)
+                sig = inspect.signature(main_func)
+                params = list(sig.parameters.values())
+
+                # Check if the function is asynchronous
+                is_async = inspect.iscoroutinefunction(main_func)
+
+                # Case 1: No parameters
+                if not params:
+                    try:
+                        result = await main_func() if is_async else main_func()
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+                input_param = params[0]
+                input_type = input_param.annotation
+
+                # Case 2: Class, dataclass, or Pydantic model parameter
+                if input_type != inspect.Parameter.empty and (
+                    is_dataclass(input_type)
+                    or self._is_pydantic_model(input_type)
+                    or hasattr(input_type, "__annotations__")
+                ):
+                    try:
+                        valid_type = cast(Type[Any], input_type)
+                        typed_input = self._convert_to_class(input_data, valid_type)
+                        result = (
+                            await main_func(typed_input)
+                            if is_async
+                            else main_func(typed_input)
+                        )
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function with typed input",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+                # Case 3: Dict parameter
+                else:
+                    try:
+                        result = (
+                            await main_func(input_data)
+                            if is_async
+                            else main_func(input_data)
+                        )
+                        return (
+                            self._convert_from_class(result)
+                            if result is not None
+                            else {}
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "FUNCTION_EXECUTION_ERROR",
+                            f"Error executing {func_name} function with dictionary input",
+                            f"Error: {str(e)}",
+                            UiPathErrorCategory.USER,
+                        ) from e
+
+        raise UiPathRuntimeError(
+            "ENTRYPOINT_FUNCTION_MISSING",
+            "No entry function found",
+            f"No main function (main, run, or execute) found in {self.entrypoint}",
+            UiPathErrorCategory.USER,
+        )
+
+    def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
+        """Convert a dictionary to either a dataclass, Pydantic model, or regular class instance."""
+        # Handle Pydantic models
+        try:
+            if inspect.isclass(cls) and issubclass(cls, BaseModel):
+                return cls.model_validate(data)
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            pass
+
+        # Handle dataclasses
+        if is_dataclass(cls):
+            field_types = get_type_hints(cls)
+            converted_data = {}
+
+            for field_name, field_type in field_types.items():
+                if field_name not in data:
+                    continue
+
+                value = data[field_name]
+                if (
+                    is_dataclass(field_type)
+                    or self._is_pydantic_model(field_type)
+                    or hasattr(field_type, "__annotations__")
+                ) and isinstance(value, dict):
+                    typed_field = cast(Type[Any], field_type)
+                    value = self._convert_to_class(value, typed_field)
+                converted_data[field_name] = value
+
+            return cls(**converted_data)
+
+        # Handle regular classes
+        else:
+            sig = inspect.signature(cls.__init__)
+            params = sig.parameters
+
+            init_args = {}
+
+            for param_name, param in params.items():
+                if param_name == "self":
+                    continue
+
+                if param_name in data:
+                    value = data[param_name]
+                    param_type = (
+                        param.annotation
+                        if param.annotation != inspect.Parameter.empty
+                        else Any
+                    )
+
+                    if (
+                        is_dataclass(param_type)
+                        or self._is_pydantic_model(param_type)
+                        or hasattr(param_type, "__annotations__")
+                    ) and isinstance(value, dict):
+                        typed_param = cast(Type[Any], param_type)
+                        value = self._convert_to_class(value, typed_param)
+
+                    init_args[param_name] = value
+                elif param.default != inspect.Parameter.empty:
+                    init_args[param_name] = param.default
+
+            return cls(**init_args)
+
+    def _is_pydantic_model(self, cls: Type[Any]) -> bool:
+        """Safely check if a class is a Pydantic model."""
+        try:
+            return inspect.isclass(cls) and issubclass(cls, BaseModel)
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            return False
+
+    def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
+        """Convert a class instance (dataclass, Pydantic model, or regular) to a dictionary."""
+        if obj is None:
+            return {}
+
+        # Handle Pydantic models
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
+        # Handle dataclasses
+        elif is_dataclass(obj):
+            # Make sure obj is an instance, not a class
+            if isinstance(obj, type):
+                return {}
+            return asdict(obj)
+
+        # Handle regular classes
+        elif hasattr(obj, "__dict__"):
+            result = {}
+            for key, value in obj.__dict__.items():
+                # Skip private attributes
+                if not key.startswith("_"):
+                    if (
+                        isinstance(value, BaseModel)
+                        or hasattr(value, "__dict__")
+                        or is_dataclass(value)
+                    ):
+                        result[key] = self._convert_from_class(value)
+                    else:
+                        result[key] = value
+            return result
+        return {} if obj is None else {str(type(obj).__name__): str(obj)}  # Fallback

uipath/_cli/cli_dev.py

@@ -6,7 +6,7 @@ import click
 
 from uipath._cli._dev._terminal import UiPathDevTerminal
 from uipath._cli._runtime._contracts import UiPathRuntimeContext, UiPathRuntimeFactory
-from uipath._cli._runtime._runtime import UiPathRuntime
+from uipath._cli._runtime._runtime import UiPathScriptRuntime
 from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli._utils._debug import setup_debugging
 from uipath._cli.cli_init import init  # type: ignore[attr-defined]
@@ -53,7 +53,9 @@ def dev(interface: Optional[str], debug: bool, debug_port: int) -> None:
 
     try:
         if interface == "terminal":
-            runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+            runtime_factory = UiPathRuntimeFactory(
+                UiPathScriptRuntime, UiPathRuntimeContext
+            )
             app = UiPathDevTerminal(runtime_factory)
             asyncio.run(app.run_async())
         else:

uipath/_cli/cli_eval.py

@@ -10,15 +10,16 @@ import click
 from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeContext,
-    UiPathRuntimeContextBuilder,
     UiPathRuntimeFactory,
 )
-from uipath._cli._runtime._runtime import UiPathRuntime
+from uipath._cli._runtime._runtime import UiPathScriptRuntime
 from uipath._cli.middlewares import MiddlewareResult, Middlewares
+from uipath.eval._helpers import auto_discover_entrypoint
 
 from .._utils.constants import ENV_JOB_ID
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
+from ._utils._eval_set import EvalHelpers
 
 console = ConsoleLogger()
 
@@ -39,42 +40,35 @@ def eval_agent_middleware(
     no_report: bool = False,
     **kwargs,
 ) -> MiddlewareResult:
-    def generate_eval_context(
-        runtime_context: UiPathRuntimeContext,
-    ) -> UiPathEvalContext:
-        os.makedirs("evals/results", exist_ok=True)
-        timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
-        base_context = UiPathRuntimeContextBuilder().with_defaults().build()
-        # TODO: the name should include the eval_set name. those files should not be commited to SW
-        base_context.execution_output_file = (
-            f"evals/results/{timestamp}.json"
-            if not os.getenv("UIPATH_JOB_KEY")
-            else None
-        )
-        return UiPathEvalContext(
-            runtime_context=runtime_context,
-            no_report=no_report,
-            workers=workers,
-            eval_set=eval_set,
-            eval_ids=eval_ids,
-            **kwargs,
-            **base_context.model_dump(),
-        )
+    """Middleware to run an evaluation set against the agent."""
+    timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
+
+    eval_context = UiPathEvalContext.with_defaults()
+    eval_context.no_report = no_report
+    eval_context.workers = workers
+    eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
+    eval_context.eval_ids = eval_ids
+    eval_context.execution_output_file = (
+        f"evals/results/{timestamp}.json" if not os.getenv("UIPATH_JOB_KEY") else None
+    )
+
+    runtime_entrypoint = entrypoint or auto_discover_entrypoint()
+
+    def generate_runtime_context(**context_kwargs) -> UiPathRuntimeContext:
+        runtime_context = UiPathRuntimeContext.with_defaults(**context_kwargs)
+        runtime_context.entrypoint = runtime_entrypoint
+        return runtime_context
 
     try:
-        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
-        context = (
-            UiPathRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_entrypoint(entrypoint)
-            .with_entrypoint(entrypoint)
-            .mark_eval_run()
-            .build()
+        runtime_factory = UiPathRuntimeFactory(
+            UiPathScriptRuntime,
+            UiPathRuntimeContext,
+            context_generator=generate_runtime_context,
         )
 
         async def execute():
             async with UiPathEvalRuntime.from_eval_context(
-                factory=runtime_factory, context=generate_eval_context(context)
+                factory=runtime_factory, context=eval_context
             ) as eval_runtime:
                 await eval_runtime.execute()
 

uipath/_cli/cli_run.py

@@ -1,9 +1,8 @@
 # type: ignore
 import asyncio
 import os
-import traceback
 from os import environ as env
-from typing import Optional, Tuple
+from typing import Optional
 
 import click
 
@@ -15,138 +14,16 @@ from .._utils.constants import (
 from ..telemetry import track
 from ._runtime._contracts import (
     UiPathRuntimeContext,
-    UiPathRuntimeContextBuilder,
     UiPathRuntimeError,
     UiPathRuntimeFactory,
 )
-from ._runtime._runtime import UiPathRuntime
+from ._runtime._runtime import UiPathScriptRuntime
 from ._utils._console import ConsoleLogger
-from .middlewares import MiddlewareResult, Middlewares
+from .middlewares import Middlewares
 
 console = ConsoleLogger()
 
 
-def python_run_middleware(
-    entrypoint: Optional[str],
-    input: Optional[str],
-    resume: bool,
-    **kwargs,
-) -> MiddlewareResult:
-    """Middleware to handle Python script execution.
-
-    Args:
-        entrypoint: Path to the Python script to execute
-        input: JSON string with input data
-        resume: Flag indicating if this is a resume execution
-        debug: Enable debugging with debugpy
-        debug_port: Port for debug server (default: 5678)
-
-    Returns:
-        MiddlewareResult with execution status and messages
-    """
-    if not entrypoint:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message="""No entrypoint specified. Please provide a path to a Python script.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    if not os.path.exists(entrypoint):
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"""Script not found at path {entrypoint}.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    try:
-        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
-        context = (
-            UiPathRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_entrypoint(entrypoint)
-            .with_input(input, input_file=kwargs.get("input_file"))
-            .with_resume(resume)
-            .build()
-        )
-
-        asyncio.run(runtime_factory.execute(context))
-
-        return MiddlewareResult(should_continue=False)
-
-    except UiPathRuntimeError as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: {e.error_info.title} - {e.error_info.detail}",
-            should_include_stacktrace=False,
-        )
-    except Exception as e:
-        # Handle unexpected errors
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: Unexpected error occurred - {str(e)}",
-            should_include_stacktrace=True,
-        )
-
-
-def run_core(
-    entrypoint: Optional[str],
-    resume: bool,
-    input: Optional[str] = None,
-    input_file: Optional[str] = None,
-    execution_output_file: Optional[str] = None,
-    logs_file: Optional[str] = None,
-    **kwargs,
-) -> Tuple[bool, Optional[str], Optional[str]]:
-    """Core execution logic that can be called programmatically.
-
-    Args:
-        entrypoint: Path to the Python script to execute
-        input: JSON string with input data
-        resume: Flag indicating if this is a resume execution
-        input_file: Path to input JSON file
-        execution_output_file: Path to execution output file
-        logs_file: Path where execution output will be written
-        **kwargs: Additional arguments to be forwarded to the middleware
-
-    Returns:
-        Tuple containing:
-            - success: True if execution was successful
-            - error_message: Error message if any
-            - info_message: Info message if any
-    """
-    # Process through middleware chain
-    result = Middlewares.next(
-        "run",
-        entrypoint,
-        input,
-        resume,
-        input_file=input_file,
-        execution_output_file=execution_output_file,
-        logs_file=logs_file,
-        **kwargs,
-    )
-
-    if result.should_continue:
-        result = python_run_middleware(
-            entrypoint=entrypoint,
-            input=input,
-            resume=resume,
-            input_file=input_file,
-            execution_output_file=execution_output_file,
-            logs_file=logs_file,
-            **kwargs,
-        )
-
-    if result.should_continue:
-        return False, "Could not process the request with any available handler.", None
-
-    return (
-        not bool(result.error_message),
-        result.error_message,
-        result.info_message,
-    )
-
-
 @click.command()
 @click.argument("entrypoint", required=False)
 @click.argument("input", required=False, default="{}")
@@ -198,27 +75,53 @@ def run(
     if not setup_debugging(debug, debug_port):
         console.error(f"Failed to start debug server on port {debug_port}")
 
-    success, error_message, info_message = run_core(
-        entrypoint=entrypoint,
-        input=input,
-        resume=resume,
+    result = Middlewares.next(
+        "run",
+        entrypoint,
+        input,
+        resume,
         input_file=input_file,
         execution_output_file=output_file,
         debug=debug,
         debug_port=debug_port,
     )
 
-    if error_message:
-        console.error(error_message, include_traceback=True)
-        if not success:  # If there was an error and execution failed
-            console.error(traceback.format_exc())
-        click.get_current_context().exit(1)
-
-    if info_message:
-        console.info(info_message)
+    if result.error_message:
+        console.error(result.error_message)
 
-    if success:
-        console.success("Successful execution.")
+    if result.should_continue:
+        if not entrypoint:
+            console.error("""No entrypoint specified. Please provide a path to a Python script.
+    Usage: `uipath run <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 run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""")
+
+        try:
+            runtime_factory = UiPathRuntimeFactory(
+                UiPathScriptRuntime, UiPathRuntimeContext
+            )
+            context = UiPathRuntimeContext.with_defaults(
+                entrypoint=entrypoint,
+                input=input,
+                input_file=input_file,
+                resume=resume,
+                execution_output_file=output_file,
+                debug=debug,
+            )
+
+            asyncio.run(runtime_factory.execute(context))
+
+        except UiPathRuntimeError as e:
+            console.error(f"{e.error_info.title} - {e.error_info.detail}")
+        except Exception as e:
+            # Handle unexpected errors
+            console.error(
+                f"Error: Unexpected error occurred - {str(e)}", include_traceback=True
+            )
+
+    console.success("Successful execution.")
 
 
 if __name__ == "__main__":

uipath/_services/processes_service.py

@@ -7,7 +7,7 @@ from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils.constants import ENV_JOB_ID, HEADER_JOB_KEY
+from .._utils.constants import ENV_JOB_KEY, HEADER_JOB_KEY
 from ..models.job import Job
 from ..tracing._traced import traced
 from . import AttachmentsService
@@ -241,7 +241,7 @@ class ProcessesService(FolderContext, BaseService):
                 **header_folder(folder_key, folder_path),
             },
         )
-        job_key = os.environ.get(ENV_JOB_ID, None)
+        job_key = os.environ.get(ENV_JOB_KEY, None)
         if job_key:
             request_scope.headers[HEADER_JOB_KEY] = job_key
         return request_scope

{uipath-2.1.44.dist-info → uipath-2.1.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.44
+Version: 2.1.45
 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

{uipath-2.1.44.dist-info → uipath-2.1.45.dist-info}/RECORD

@@ -8,8 +8,8 @@ uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=kf4GINkunFGMZkTk2Z4f1Q3-OsxpNnV6u_9BsBt1i0E,2229
 uipath/_cli/cli_auth.py,sha256=i3ykLlCg68xgPXHHaa0agHwGFIiLiTLzOiF6Su8XaEo,2436
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
-uipath/_cli/cli_dev.py,sha256=JRzXrAUM_sj6FCVG-VveYADTwR8yQ330SgYs3LgbvJc,2104
-uipath/_cli/cli_eval.py,sha256=ZXCwjNBgp-aROIA9hcl2w5eqsrxWJAteAPmWs4hEwKQ,4525
+uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
+uipath/_cli/cli_eval.py,sha256=fYJWQlyiIc8SpTzY9QPNQWOx40PagMEKdsGZIu9As2A,4402
 uipath/_cli/cli_init.py,sha256=ls577uNm2zWccknIhtVFS3ah2ds0QSy2_TgMp6z7Wt4,6049
 uipath/_cli/cli_invoke.py,sha256=4jyhqcy7tPrpxvaUhW-9gut6ddsCGMdJJcpOXXmIe8g,4348
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
@@ -17,7 +17,7 @@ uipath/_cli/cli_pack.py,sha256=NmwZTfwZ2fURiHyiX1BM0juAtBOjPB1Jmcpu-rD7p-4,11025
 uipath/_cli/cli_publish.py,sha256=FmBCdeh4zFaESOLfzTTPxGcOwUtsQ_WkvF_fjHEdU8s,6448
 uipath/_cli/cli_pull.py,sha256=vwS0KMX6O2L6RaPy8tw_qzXe4dC7kf_G6nbLm0I62eI,6831
 uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
-uipath/_cli/cli_run.py,sha256=C0V7Tt_kYAk2vbQO7hVE6DRUqZW1Xo35LgqhnQhF3Ng,6539
+uipath/_cli/cli_run.py,sha256=7CJ3e388KCXzB5qh1eHIOL4fe7lMIxt7_1kC7iAz0A8,3559
 uipath/_cli/middlewares.py,sha256=GvMhDnx1BmA7rIe12s6Uqv1JdqNZhvraU0a91oqGag4,4976
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=22km0F1NFNXgyLbvtAx3ssiQlVGHroLdtDCWEqiCiMg,7106
@@ -44,7 +44,7 @@ uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i
 uipath/_cli/_dev/_terminal/_utils/_chat.py,sha256=YUZxYVdmEManwHDuZsczJT1dWIYE1dVBgABlurwMFcE,8493
 uipath/_cli/_dev/_terminal/_utils/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
 uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=jeNShEED27cNIHTe_NNx-2kUiXpSLTmi0onM6tVkqRM,888
-uipath/_cli/_evals/_runtime.py,sha256=PEMaW7EOHyyIgqDVMEdSKmGbRAO15HtZpzV4Jgmjuq0,5948
+uipath/_cli/_evals/_runtime.py,sha256=q4h3zp_7Ygkhj1zE_YTKKXRp3BhkHaPj8CWqjkzerTk,4748
 uipath/_cli/_evals/progress_reporter.py,sha256=m1Dio1vG-04nFTFz5ijM_j1dhudlgOzQukmTkkg6wS4,11490
 uipath/_cli/_evals/_evaluators/__init__.py,sha256=jD7KNLjbsUpsESFXX11eW2MEPXDNuPp2-t-IPB-inlM,734
 uipath/_cli/_evals/_evaluators/_deterministic_evaluator_base.py,sha256=BTl0puBjp9iCsU3YFfYWqk4TOz4iE19O3q1-dK6qUOI,1723
@@ -59,11 +59,12 @@ uipath/_cli/_evals/_models/_agent_execution_output.py,sha256=llvApU4JkTnNgQ5DvHP
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=tVHykSget-G3sOCs9bSchMYUTpFqzXVlYYbY8L9SI0c,1518
 uipath/_cli/_evals/_models/_evaluators.py,sha256=l57NEVyYmzSKuoIXuGkE94Br01hAMg35fiS2MlTkaQM,2115
 uipath/_cli/_push/sw_file_handler.py,sha256=AX4TKM-q6CNGw3JyBW02M8ktPZuFMcAU9LN3Ii0Q2QI,18202
-uipath/_cli/_runtime/_contracts.py,sha256=C1zocpvNWgq6FUhWJZpVvoWrH2GBS3xA229PcMovYdY,25975
+uipath/_cli/_runtime/_contracts.py,sha256=Utkyu2540_ytyGN450CRXeK2ilPpfJL_npCGdMs4Jic,28195
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
 uipath/_cli/_runtime/_logging.py,sha256=MGklGKPjYKjs7J5Jy9eplA9zCDsdtEbkZdCbTwgut_4,8311
-uipath/_cli/_runtime/_runtime.py,sha256=TXtXzscRPLdYJURH0Y-7sXsigC-2k_LttBOz7EUfWUQ,11449
+uipath/_cli/_runtime/_runtime.py,sha256=gby9-avNNlEATEfSXtY8FfJ8nREsSCGA4wMgDlSXTDE,2297
+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
 uipath/_cli/_templates/[Content_Types].xml.template,sha256=bYsKDz31PkIF9QksjgAY_bqm57YC8U_owsZeNZAiBxQ,584
@@ -94,7 +95,7 @@ uipath/_services/context_grounding_service.py,sha256=EBf7lIIYz_s1ubf_07OAZXQHjS8
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
 uipath/_services/jobs_service.py,sha256=UwsY0Cir7Yd5_mTeH0uHLmcmQZpdbT8KNx3z3F0cHZA,32775
 uipath/_services/llm_gateway_service.py,sha256=oZR--75V8ULdLjVC7lo-lJ5786J_qfXUDe0R9iWNAKs,24306
-uipath/_services/processes_service.py,sha256=y2LWLIpvWnmcdtKgXCA7q0a5WPD4mBeitTICHYTQng0,8505
+uipath/_services/processes_service.py,sha256=MxNyNo6EdSUhmp7QX9HYUU2JsZfiOcW7OUl86To2fXs,8507
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
 uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
 uipath/_utils/_endpoint.py,sha256=yYHwqbQuJIevpaTkdfYJS9CrtlFeEyfb5JQK5osTCog,2489
@@ -144,8 +145,8 @@ uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,185
 uipath/tracing/_utils.py,sha256=wJRELaPu69iY0AhV432Dk5QYf_N_ViRU4kAUG1BI1ew,10384
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.44.dist-info/METADATA,sha256=63AwBAFGwMtIvk-7t6s5vuZ6YZoSG1vPyX-JIYtVkUo,6482
-uipath-2.1.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.44.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.44.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.44.dist-info/RECORD,,
+uipath-2.1.45.dist-info/METADATA,sha256=Wl0xmOEDkPCFK1l_eB_Bj2nKUn7y0cusfLzcC5hiVmE,6482
+uipath-2.1.45.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.45.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.45.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.45.dist-info/RECORD,,