uipath 2.1.90__py3-none-any.whl → 2.1.92__py3-none-any.whl

uipath/_cli/_evals/_runtime.py

@@ -326,7 +326,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         if eval_item.input_mocking_strategy:
             eval_item = await self._generate_input_for_eval(eval_item)
 
-        set_execution_context(eval_item, self.span_collector)
+        execution_id = str(uuid.uuid4())
+        set_execution_context(eval_item, self.span_collector, execution_id)
 
         await event_bus.publish(
             EvaluationEvents.CREATE_EVAL_RUN,
@@ -341,7 +342,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         )
 
         try:
-            agent_execution_output = await self.execute_runtime(eval_item)
+            agent_execution_output = await self.execute_runtime(eval_item, execution_id)
             evaluation_item_results: list[EvalItemResult] = []
 
             for evaluator in evaluators:
@@ -448,9 +449,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         return spans, logs
 
     async def execute_runtime(
-        self, eval_item: EvaluationItem
+        self, eval_item: EvaluationItem, execution_id: str
     ) -> UiPathEvalRunExecutionOutput:
-        execution_id = str(uuid.uuid4())
         runtime_context: C = self.factory.new_context(
             execution_id=execution_id,
             input_json=eval_item.inputs,

uipath/_cli/_evals/mocks/llm_mocker.py

@@ -96,7 +96,11 @@ class LLMMocker(Mocker):
             from uipath import UiPath
             from uipath._services.llm_gateway_service import _cleanup_schema
 
-            from .mocks import evaluation_context, span_collector_context
+            from .mocks import (
+                evaluation_context,
+                execution_id_context,
+                span_collector_context,
+            )
 
             llm = UiPath().llm
             return_type: Any = func.__annotations__.get("return", None)
@@ -126,8 +130,9 @@ class LLMMocker(Mocker):
                 test_run_history = "(empty)"
                 eval_item = evaluation_context.get()
                 span_collector = span_collector_context.get()
-                if eval_item and span_collector:
-                    spans = span_collector.get_spans(eval_item.id)
+                execution_id = execution_id_context.get()
+                if eval_item and span_collector and execution_id:
+                    spans = span_collector.get_spans(execution_id)
                     test_run_history = _SpanUtils.spans_to_llm_context(spans)
 
                 prompt_input: dict[str, Any] = {

uipath/_cli/_evals/mocks/mocks.py

@@ -21,11 +21,16 @@ span_collector_context: ContextVar[Optional[ExecutionSpanCollector]] = ContextVa
     "span_collector", default=None
 )
 
+# Execution ID for the current evaluation item
+execution_id_context: ContextVar[Optional[str]] = ContextVar(
+    "execution_id", default=None
+)
+
 logger = logging.getLogger(__name__)
 
 
 def set_execution_context(
-    eval_item: EvaluationItem, span_collector: ExecutionSpanCollector
+    eval_item: EvaluationItem, span_collector: ExecutionSpanCollector, execution_id: str
 ) -> None:
     """Set the execution context for an evaluation run for mocking and trace access."""
     evaluation_context.set(eval_item)
@@ -40,6 +45,7 @@ def set_execution_context(
         mocker_context.set(None)
 
     span_collector_context.set(span_collector)
+    execution_id_context.set(execution_id)
 
 
 def clear_execution_context() -> None:
@@ -47,6 +53,7 @@ def clear_execution_context() -> None:
     evaluation_context.set(None)
     mocker_context.set(None)
     span_collector_context.set(None)
+    execution_id_context.set(None)
 
 
 async def get_mocked_response(

uipath/_cli/_push/sw_file_handler.py

@@ -319,7 +319,7 @@ class SwFileHandler:
         if existing:
             try:
                 entry_points_json = (
-                    await self._studio_client.download_file_async(existing.id)
+                    await self._studio_client.download_project_file_async(existing)
                 ).json()
                 entry_points_json["entryPoints"] = uipath_config["entryPoints"]
 
@@ -417,7 +417,7 @@ class SwFileHandler:
         if existing:
             try:
                 existing_agent_json = (
-                    await self._studio_client.download_file_async(existing.id)
+                    await self._studio_client.download_project_file_async(existing)
                 ).json()
                 version_parts = existing_agent_json["metadata"]["codeVersion"].split(
                     "."
@@ -453,7 +453,7 @@ class SwFileHandler:
             )
             logger.info("Uploading 'agent.json'")
 
-    async def upload_source_files(self, config_data: dict[str, Any]) -> None:
+    async def upload_source_files(self, settings: Optional[dict[str, Any]]) -> None:
         """Main method to upload source files to the UiPath project.
 
         - Gets project structure
@@ -462,7 +462,7 @@ class SwFileHandler:
         - Deletes removed files
 
         Args:
-            config_data: Project configuration data
+            settings: File handling settings
 
         Returns:
             Dict[str, ProjectFileExtended]: Root level files for agent.json handling
@@ -493,7 +493,7 @@ class SwFileHandler:
 
         # Get files to upload and process them
         files = files_to_include(
-            config_data,
+            settings,
             self.directory,
             self.include_uv_lock,
             directories_to_ignore=["evals"],

uipath/_cli/_runtime/_contracts.py

@@ -8,7 +8,19 @@ import traceback
 from abc import ABC, abstractmethod
 from enum import Enum
 from functools import cached_property
-from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar, Union
+from typing import (
+    Any,
+    AsyncGenerator,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 from uuid import uuid4
 
 from opentelemetry import context as context_api
@@ -23,6 +35,7 @@ from opentelemetry.sdk.trace.export import (
 from opentelemetry.trace import Tracer
 from pydantic import BaseModel, Field
 
+from uipath._events._events import BaseEvent
 from uipath.agent.conversation import UiPathConversationEvent, UiPathConversationMessage
 from uipath.tracing import TracingManager
 
@@ -143,6 +156,19 @@ class UiPathRuntimeResult(BaseModel):
         return result
 
 
+class UiPathRuntimeBreakpointResult(UiPathRuntimeResult):
+    """Result for execution suspended at a breakpoint."""
+
+    # Force status to always be SUSPENDED
+    status: UiPathRuntimeStatus = Field(
+        default=UiPathRuntimeStatus.SUSPENDED, frozen=True
+    )
+    breakpoint_node: str  # Which node the breakpoint is at
+    breakpoint_type: Literal["before", "after"]  # Before or after the node
+    current_state: dict[str, Any] | Any  # Current workflow state at breakpoint
+    next_nodes: List[str]  # Which node(s) will execute next
+
+
 class UiPathConversationHandler(ABC):
     """Base delegate for handling UiPath conversation events."""
 
@@ -548,6 +574,47 @@ class UiPathBaseRuntime(ABC):
         """
         pass
 
+    async def stream(
+        self,
+    ) -> AsyncGenerator[Union[BaseEvent, UiPathRuntimeResult], None]:
+        """Stream execution events in real-time.
+
+        This is an optional method that runtimes can implement to support streaming.
+        If not implemented, only the execute() method will be available.
+
+        Yields framework-agnostic BaseEvent instances during execution,
+        with the final event being UiPathRuntimeResult.
+
+        Yields:
+            BaseEvent subclasses: Framework-agnostic events (MessageCreatedEvent,
+                                  AgentStateUpdatedEvent, etc.)
+            Final yield: UiPathRuntimeResult
+
+        Raises:
+            NotImplementedError: If the runtime doesn't support streaming
+            RuntimeError: If execution fails
+
+        Example:
+            async for event in runtime.stream():
+                if isinstance(event, UiPathRuntimeResult):
+                    # Last event - execution complete
+                    print(f"Status: {event.status}")
+                    break
+                elif isinstance(event, MessageCreatedEvent):
+                    # Handle message event
+                    print(f"Message: {event.payload}")
+                elif isinstance(event, AgentStateUpdatedEvent):
+                    # Handle state update
+                    print(f"State updated by: {event.node_name}")
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not implement streaming. "
+            "Use execute() instead."
+        )
+        # This yield is unreachable but makes this a proper generator function
+        # Without it, the function wouldn't match the AsyncGenerator return type
+        yield
+
     @abstractmethod
     async def validate(self):
         """Validate runtime inputs."""

uipath/_cli/_utils/_parse_ast.py

@@ -13,6 +13,7 @@ from ..._services import (
     ProcessesService,
 )
 from ..._utils import get_inferred_bindings_names
+from ..models.runtime_schema import BindingResource, BindingResourceValue, Bindings
 from ._constants import BINDINGS_VERSION
 
 
@@ -428,7 +429,7 @@ def parse_sdk_usage(
     return results
 
 
-def convert_to_bindings_format(sdk_usage_data):
+def convert_to_bindings_format(sdk_usage_data) -> Bindings:
     """Convert the output of parse_sdk_usage to a structure similar to bindings_v2.json.
 
     Args:
@@ -437,7 +438,7 @@ def convert_to_bindings_format(sdk_usage_data):
     Returns:
         Dictionary in bindings_v2.json format
     """
-    bindings = {"version": "2.0", "resources": []}
+    bindings = Bindings(version="2.0", resources=[])
 
     for resource_type, components in sdk_usage_data.items():
         for component in components:
@@ -448,24 +449,24 @@ def convert_to_bindings_format(sdk_usage_data):
                 )
                 is_connection_id_expression = connection_id.startswith("EXPR$")
                 connection_id = connection_id.replace("EXPR$", "")
-                resource_entry = {
-                    "resource": "connection",
-                    "key": connection_id,
-                    "value": {
-                        "ConnectionId": {
-                            "defaultValue": connection_id,
-                            "isExpression": is_connection_id_expression,
-                            "displayName": "Connection",
-                        }
+                resource_entry = BindingResource(
+                    resource="connection",
+                    key=connection_id,
+                    value={
+                        "ConnectionId": BindingResourceValue(
+                            default_value=connection_id,
+                            is_expression=is_connection_id_expression,
+                            display_name="Connection",
+                        ),
                     },
-                    "metadata": {
+                    metadata={
                         "BindingsVersion": BINDINGS_VERSION,
                         "Connector": connector_name,
                         "UseConnectionService": "True",
                     },
-                }
+                )
 
-                bindings["resources"].append(resource_entry)
+                bindings.resources.append(resource_entry)
                 continue
 
             resource_name = component.get("name", "")
@@ -481,36 +482,61 @@ def convert_to_bindings_format(sdk_usage_data):
             key = name
             if folder_path:
                 key = f"{folder_path}.{name}"
-            resource_entry = {
-                "resource": service_name_resource_mapping[resource_type],
-                "key": key,
-                "value": {
-                    "name": {
-                        "defaultValue": name,
-                        "isExpression": is_expression,
-                        "displayName": "Name",
-                    }
+            resource_entry = BindingResource(
+                resource=service_name_resource_mapping[resource_type],
+                key=key,
+                value={
+                    "name": BindingResourceValue(
+                        default_value=name,
+                        is_expression=is_expression,
+                        display_name="Name",
+                    ),
                 },
-                "metadata": {
+                metadata={
                     "ActivityName": method_name,
                     "BindingsVersion": BINDINGS_VERSION,
                     "DisplayLabel": "FullName",
                 },
-            }
+            )
 
             if folder_path:
-                resource_entry["value"]["folderPath"] = {
-                    "defaultValue": folder_path,
-                    "isExpression": is_folder_path_expression,
-                    "displayName": "Folder Path",
-                }
+                resource_entry.value["folderPath"] = BindingResourceValue(
+                    default_value=folder_path,
+                    is_expression=is_folder_path_expression,
+                    display_name="Folder Path",
+                )
 
-            bindings["resources"].append(resource_entry)
+            bindings.resources.append(resource_entry)
 
     return bindings
 
 
-def generate_bindings_json(file_path: str) -> str:
+def generate_bindings_json(file_path: str) -> dict[str, Any]:
+    """Generate bindings JSON from a Python file.
+
+    Args:
+        file_path: Path to the Python file to analyze
+
+    Returns:
+        JSON string representation of the bindings
+    """
+    try:
+        with open(file_path, "r") as f:
+            source_code = f.read()
+
+        # Get the base directory for resolving imports
+        base_dir = os.path.dirname(os.path.abspath(file_path))
+
+        sdk_usage = parse_sdk_usage(source_code, base_dir)
+        bindings = convert_to_bindings_format(sdk_usage)
+
+        return bindings.model_dump(by_alias=True)
+
+    except Exception as e:
+        raise Exception(f"Error generating bindings JSON: {e}") from e
+
+
+def generate_bindings(file_path: str) -> Bindings:
     """Generate bindings JSON from a Python file.
 
     Args:

uipath/_cli/_utils/_project_files.py

@@ -7,9 +7,10 @@ import re
 from pathlib import Path
 from typing import Any, Dict, Optional, Protocol, Tuple
 
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 
 from .._utils._console import ConsoleLogger
+from ..models.runtime_schema import RuntimeSchema
 from ._constants import is_binary_file
 from ._studio_project import (
     ProjectFile,
@@ -93,21 +94,19 @@ def get_project_config(directory: str) -> dict[str, str]:
         console.error("pyproject.toml not found.")
 
     with open(config_path, "r") as config_file:
-        config_data = json.load(config_file)
-
-    validate_config_structure(config_data)
+        config_data = TypeAdapter(RuntimeSchema).validate_python(json.load(config_file))
 
     toml_data = read_toml_project(toml_path)
 
     return {
         "project_name": toml_data["name"],
         "description": toml_data["description"],
-        "entryPoints": config_data["entryPoints"],
+        "entryPoints": [ep.model_dump(by_alias=True) for ep in config_data.entrypoints],
         "version": toml_data["version"],
         "authors": toml_data["authors"],
         "dependencies": toml_data.get("dependencies", {}),
         "requires-python": toml_data.get("requires-python", None),
-        "settings": config_data.get("settings", {}),
+        "settings": config_data.settings or {},
     }
 
 
@@ -347,7 +346,7 @@ def read_toml_project(file_path: str) -> dict:
 
 
 def files_to_include(
-    config_data: Optional[dict[Any, Any]],
+    settings: Optional[dict[str, Any]],
     directory: str,
     include_uv_lock: bool = True,
     directories_to_ignore: list[str] | None = None,
@@ -358,7 +357,7 @@ def files_to_include(
     and explicit inclusion rules. Skips virtual environments and hidden directories.
 
     Args:
-        config_data: Configuration containing file inclusion rules
+        settings: File handling settings
         directory: Root directory to search for files
         include_uv_lock: Whether to include uv.lock file
         directories_to_ignore: List of directories to ignore
@@ -374,8 +373,7 @@ def files_to_include(
         directories_to_ignore = []
     if include_uv_lock:
         files_included += ["uv.lock"]
-    if "settings" in config_data:
-        settings = config_data["settings"]
+    if settings is not None:
         if "fileExtensionsIncluded" in settings:
             file_extensions_included.extend(settings["fileExtensionsIncluded"])
         if "filesIncluded" in settings:
@@ -559,7 +557,7 @@ async def download_folder_files(
         local_path = base_path / file_path
         local_path.parent.mkdir(parents=True, exist_ok=True)
 
-        response = await studio_client.download_file_async(remote_file.id)
+        response = await studio_client.download_project_file_async(remote_file)
         remote_content = response.read().decode("utf-8")
         remote_hash = compute_normalized_hash(remote_content)
 

uipath/_cli/_utils/_studio_project.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from uipath._utils.constants import HEADER_SW_LOCK_KEY
 from uipath.models.exceptions import EnrichedException
+from uipath.tracing import traced
 
 
 class ProjectFile(BaseModel):
@@ -231,6 +232,7 @@ class StudioSolutionsClient:
         self.uipath: UiPath = UiPath()
         self._solutions_base_url: str = f"/studio_/backend/api/Solution/{solution_id}"
 
+    @traced(name="create_project", run_type="uipath")
     async def create_project_async(
         self,
         project_name: str,
@@ -275,6 +277,7 @@ class StudioClient:
             f"/studio_/backend/api/Project/{project_id}/Lock"
         )
 
+    @traced(name="get_project_structure", run_type="uipath")
     async def get_project_structure_async(self) -> ProjectStructure:
         """Retrieve the project's file structure from UiPath Cloud.
 
@@ -293,6 +296,7 @@ class StudioClient:
 
         return ProjectStructure.model_validate(response.json())
 
+    @traced(name="create_folder", run_type="uipath")
     @with_lock_retry
     async def create_folder_async(
         self,
@@ -322,6 +326,7 @@ class StudioClient:
         )
         return response.json()
 
+    @traced(name="download_file", run_type="uipath")
     async def download_file_async(self, file_id: str) -> Any:
         response = await self.uipath.api_client.request_async(
             "GET",
@@ -330,6 +335,16 @@ class StudioClient:
         )
         return response
 
+    @traced(name="download_file", run_type="uipath")
+    async def download_project_file_async(self, file: ProjectFile) -> Any:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/File/{file.id}",
+            scoped="org",
+        )
+        return response
+
+    @traced(name="upload_file", run_type="uipath")
     @with_lock_retry
     async def upload_file_async(
         self,
@@ -370,6 +385,7 @@ class StudioClient:
         # response contains only the uploaded file identifier
         return response.json(), action
 
+    @traced(name="delete_file", run_type="uipath")
     @with_lock_retry
     async def delete_item_async(
         self,
@@ -430,6 +446,7 @@ class StudioClient:
 
         return content_bytes, resolved_name
 
+    @traced(name="synchronize_files", run_type="uipath")
     @with_lock_retry
     async def perform_structural_migration_async(
         self,

uipath/_cli/cli_init.py

@@ -15,8 +15,9 @@ from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
 from ._utils._console import ConsoleLogger
 from ._utils._input_args import generate_args
-from ._utils._parse_ast import generate_bindings_json
+from ._utils._parse_ast import generate_bindings
 from .middlewares import Middlewares
+from .models.runtime_schema import Bindings, Entrypoint, RuntimeSchema
 
 console = ConsoleLogger()
 logger = logging.getLogger(__name__)
@@ -152,13 +153,17 @@ def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optiona
         return None
 
 
-def write_config_file(config_data: Dict[str, Any]) -> None:
+def write_config_file(config_data: Dict[str, Any] | RuntimeSchema) -> None:
     existing_settings = get_existing_settings(CONFIG_PATH)
     if existing_settings is not None:
-        config_data["settings"] = existing_settings
+        config_data.settings = existing_settings
 
     with open(CONFIG_PATH, "w") as config_file:
-        json.dump(config_data, config_file, indent=4)
+        if isinstance(config_data, RuntimeSchema):
+            json_object = config_data.model_dump(by_alias=True, exclude_unset=True)
+        else:
+            json_object = config_data
+        json.dump(json_object, config_file, indent=4)
 
     return CONFIG_PATH
 
@@ -208,30 +213,29 @@ def init(entrypoint: str, infer_bindings: bool) -> None:
             args = generate_args(script_path)
 
             relative_path = Path(script_path).relative_to(current_directory).as_posix()
-
-            config_data = {
-                "entryPoints": [
-                    {
-                        "filePath": relative_path,
-                        "uniqueId": str(uuid.uuid4()),
-                        # "type": "process", OR BE doesn't offer json schema support for type: Process
-                        "type": "agent",
-                        "input": args["input"],
-                        "output": args["output"],
-                    }
-                ]
-            }
-
-            # Generate bindings JSON based on the script path
-            try:
-                if infer_bindings:
-                    bindings_data = generate_bindings_json(script_path)
-                else:
-                    bindings_data = {}
-                # Add bindings to the config data
-                config_data["bindings"] = bindings_data
-            except Exception as e:
-                console.warning(f"Warning: Could not generate bindings: {str(e)}")
+            bindings = None
+            if infer_bindings:
+                try:
+                    bindings = generate_bindings(script_path)
+                except Exception as e:
+                    console.warning(f"Warning: Could not generate bindings: {str(e)}")
+            if bindings is None:
+                bindings = Bindings(
+                    version="2.0",
+                    resources=[],
+                )
+            config_data = RuntimeSchema(
+                entrypoints=[
+                    Entrypoint(
+                        file_path=relative_path,
+                        unique_id=str(uuid.uuid4()),
+                        type="agent",
+                        input=args["input"],
+                        output=args["output"],
+                    )
+                ],
+                bindings=bindings,
+            )
 
             config_path = write_config_file(config_data)
             console.success(f"Created '{config_path}' file.")

uipath/_cli/cli_pack.py

@@ -6,8 +6,10 @@ import zipfile
 from string import Template
 
 import click
+from pydantic import TypeAdapter
 
 from uipath._cli._utils._constants import UIPATH_PROJECT_ID
+from uipath._cli.models.runtime_schema import Bindings, RuntimeSchema
 
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
@@ -101,10 +103,11 @@ def generate_entrypoints_file(entryPoints):
     return entrypoint_json_data
 
 
-def generate_bindings_content():
-    bindings_content = {"version": "2.0", "resources": []}
-
-    return bindings_content
+def generate_bindings_content() -> Bindings:
+    return Bindings(
+        version="2.0",
+        resources=[],
+    )
 
 
 def generate_content_types_content():
@@ -214,11 +217,7 @@ def pack_fn(
         console.error("uipath.json not found, please run `uipath init`.")
 
     with open(config_path, "r") as f:
-        config_data = json.load(f)
-        if "bindings" in config_data:
-            bindings_content = config_data["bindings"]
-        else:
-            bindings_content = generate_bindings_content()
+        config_data = TypeAdapter(RuntimeSchema).validate_python(json.load(f))
 
     content_types_content = generate_content_types_content()
     [psmdcp_file_name, psmdcp_content] = generate_psmdcp_content(
@@ -249,11 +248,14 @@ def pack_fn(
         )
         z.writestr("content/operate.json", json.dumps(operate_file, indent=4))
         z.writestr("content/entry-points.json", json.dumps(entrypoints_file, indent=4))
-        z.writestr("content/bindings_v2.json", json.dumps(bindings_content, indent=4))
+        z.writestr(
+            "content/bindings_v2.json",
+            json.dumps(config_data.bindings.model_dump(by_alias=True), indent=4),
+        )
         z.writestr(f"{projectName}.nuspec", nuspec_content)
         z.writestr("_rels/.rels", rels_content)
 
-        files = files_to_include(config_data, directory, include_uv_lock)
+        files = files_to_include(config_data.settings, directory, include_uv_lock)
 
         for file in files:
             if file.is_binary: