uipath 2.1.44__tar.gz → 2.1.46__tar.gz

{uipath-2.1.44 → uipath-2.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.44
+Version: 2.1.46
 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 → uipath-2.1.46}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.44"
+version = "2.1.46"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.44 → uipath-2.1.46}/src/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-2.1.44 → uipath-2.1.46}/src/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,48 @@ 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)
+
+        bool_map = {"true": True, "false": False}
+        tracing_enabled = os.environ.get("UIPATH_TRACING_ENABLED", True)
+        if isinstance(tracing_enabled, str) and tracing_enabled.lower() in bool_map:
+            tracing_enabled = bool_map[tracing_enabled.lower()]
+
+        # 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 = tracing_enabled
+        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=tracing_enabled,
+            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 +376,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 +383,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 +410,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 +500,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 +662,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 +684,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 +719,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-2.1.46/src/uipath/_cli/_runtime/_runtime.py

@@ -0,0 +1,79 @@
+"""Python script runtime implementation for executing and managing python scripts."""
+
+import logging
+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):
+    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.
+
+        Returns:
+            Dictionary with execution results
+
+        Raises:
+            UiPathRuntimeError: If execution fails
+        """
+        try:
+            script_result = await self.executor(self.context.input_json)
+
+            if self.context.job_id is None:
+                logger.info(script_result)
+
+            self.context.result = UiPathRuntimeResult(
+                output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
+            )
+
+            return self.context.result
+
+        except Exception as e:
+            if isinstance(e, UiPathRuntimeError):
+                raise
+
+            raise UiPathRuntimeError(
+                "EXECUTION_ERROR",
+                "Python script execution failed",
+                f"Error: {str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
+
+
+class UiPathScriptRuntime(UiPathRuntime):
+    """Runtime for executing Python scripts."""
+
+    def __init__(self, context: UiPathRuntimeContext, entrypoint: str):
+        executor = ScriptExecutor(entrypoint)
+        super().__init__(context, executor)
+
+    @classmethod
+    def from_context(cls, context: UiPathRuntimeContext):
+        """Create runtime instance from context."""
+        return UiPathScriptRuntime(context, context.entrypoint or "")

uipath-2.1.44/src/uipath/_cli/_runtime/_runtime.py → uipath-2.1.46/src/uipath/_cli/_runtime/_script_executor.py

@@ -2,72 +2,31 @@
 
 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 typing import Any, Dict, Type, TypeVar, cast, get_type_hints
 
 from pydantic import BaseModel
 
 from ._contracts import (
-    UiPathBaseRuntime,
     UiPathErrorCategory,
     UiPathRuntimeError,
-    UiPathRuntimeResult,
-    UiPathRuntimeStatus,
 )
 
-logger = logging.getLogger(__name__)
-
 T = TypeVar("T")
 
 
-class UiPathRuntime(UiPathBaseRuntime):
-    """Runtime for executing Python scripts."""
-
-    async def execute(self) -> Optional[UiPathRuntimeResult]:
-        """Execute the Python script with the provided input and configuration.
-
-        Returns:
-            Dictionary with execution results
-
-        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
-            )
-
-            if self.context.job_id is None:
-                logger.info(script_result)
-
-            self.context.result = UiPathRuntimeResult(
-                output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
-            )
-
-            return self.context.result
-
-        except Exception as e:
-            if isinstance(e, UiPathRuntimeError):
-                raise
+class ScriptExecutor:
+    def __init__(self, entrypoint: str):
+        self.entrypoint = entrypoint
+        self.validate_entrypoint()
 
-            raise UiPathRuntimeError(
-                "EXECUTION_ERROR",
-                "Python script execution failed",
-                f"Error: {str(e)}",
-                UiPathErrorCategory.SYSTEM,
-            ) from e
+    async def __call__(self, input: Any) -> Any:
+        return await self._execute_python_script(input)
 
-    async def validate(self) -> None:
+    def validate_entrypoint(self) -> None:
         """Validate runtime inputs."""
-        if not self.context.entrypoint:
+        if not self.entrypoint:
             raise UiPathRuntimeError(
                 "ENTRYPOINT_MISSING",
                 "No entrypoint specified",
@@ -75,39 +34,22 @@ class UiPathRuntime(UiPathBaseRuntime):
                 UiPathErrorCategory.USER,
             )
 
-        if not os.path.exists(self.context.entrypoint):
+        if not os.path.exists(self.entrypoint):
             raise UiPathRuntimeError(
                 "ENTRYPOINT_NOT_FOUND",
                 "Script not found",
-                f"Script not found at path {self.context.entrypoint}.",
+                f"Script not found at path {self.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:
+    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", script_path)
+        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 {script_path}",
+                f"Could not load spec for {self.entrypoint}",
                 UiPathErrorCategory.USER,
             )
 
@@ -202,7 +144,7 @@ class UiPathRuntime(UiPathBaseRuntime):
         raise UiPathRuntimeError(
             "ENTRYPOINT_FUNCTION_MISSING",
             "No entry function found",
-            f"No main function (main, run, or execute) found in {script_path}",
+            f"No main function (main, run, or execute) found in {self.entrypoint}",
             UiPathErrorCategory.USER,
         )
 

{uipath-2.1.44 → uipath-2.1.46}/src/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-2.1.44 → uipath-2.1.46}/src/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()