uipath 2.1.89__py3-none-any.whl → 2.1.91__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

@@ -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/_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:

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__)
@@ -60,20 +61,17 @@ def generate_env_file(target_directory):
         console.success(f"Created '{relative_path}' file.")
 
 
-def generate_agent_specific_file_md(target_directory: str, file_name: str) -> None:
+def generate_agent_md_file(target_directory: str, file_name: str) -> None:
     """Generate an agent-specific file from the packaged resource.
 
     Args:
         target_directory: The directory where the file should be created.
         file_name: The name of the file should be created.
     """
-    agent_dir = os.path.join(target_directory, ".agent")
-    os.makedirs(agent_dir, exist_ok=True)
-
-    target_path = os.path.join(agent_dir, file_name)
+    target_path = os.path.join(target_directory, file_name)
 
     if os.path.exists(target_path):
-        logger.debug(f"File '.agent/{target_path}' already exists.")
+        logger.debug(f"File '{target_path}' already exists.")
         return
 
     try:
@@ -82,11 +80,32 @@ def generate_agent_specific_file_md(target_directory: str, file_name: str) -> No
         with importlib.resources.as_file(source_path) as s_path:
             shutil.copy(s_path, target_path)
 
-        console.success(f"Created '{f'.agent/{file_name}'}' file.")
     except Exception as e:
         console.warning(f"Could not create {file_name}: {e}")
 
 
+def generate_agent_md_files(target_directory: str) -> None:
+    """Generate an agent-specific file from the packaged resource.
+
+    Args:
+        target_directory: The directory where the files should be created.
+    """
+    agent_dir = os.path.join(target_directory, ".agent")
+    os.makedirs(agent_dir, exist_ok=True)
+
+    root_files = ["AGENTS.md", "CLAUDE.md"]
+
+    agent_files = ["CLI_REFERENCE.md", "REQUIRED_STRUCTURE.md", "SDK_REFERENCE.md"]
+
+    for file_name in root_files:
+        generate_agent_md_file(target_directory, file_name)
+
+    for file_name in agent_files:
+        generate_agent_md_file(agent_dir, file_name)
+
+    console.success(f"Created {click.style('AGENTS.md', fg='cyan')} file.")
+
+
 def get_existing_settings(config_path: str) -> Optional[Dict[str, Any]]:
     """Read existing settings from uipath.json if it exists.
 
@@ -134,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
 
@@ -161,11 +184,6 @@ def init(entrypoint: str, infer_bindings: bool) -> None:
         current_directory = os.getcwd()
         generate_env_file(current_directory)
         create_telemetry_config_file(current_directory)
-        generate_agent_specific_file_md(current_directory, "AGENTS.md")
-        generate_agent_specific_file_md(current_directory, "CLI_REFERENCE.md")
-        generate_agent_specific_file_md(current_directory, "REQUIRED_STRUCTURE.md")
-        generate_agent_specific_file_md(current_directory, "SDK_REFERENCE.md")
-        generate_agent_specific_file_md(current_directory, "CLAUDE.md")
 
         result = Middlewares.next(
             "init",
@@ -185,6 +203,7 @@ def init(entrypoint: str, infer_bindings: bool) -> None:
         if not result.should_continue:
             return
 
+        generate_agent_md_files(current_directory)
         script_path = get_user_script(current_directory, entrypoint=entrypoint)
 
         if not script_path:
@@ -194,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:

uipath/_cli/cli_push.py

@@ -1,7 +1,7 @@
 # type: ignore
 import asyncio
 import os
-from typing import Any
+from typing import Any, Optional
 from urllib.parse import urlparse
 
 import click
@@ -32,7 +32,7 @@ def get_org_scoped_url(base_url: str) -> str:
 
 async def upload_source_files_to_project(
     project_id: str,
-    config_data: dict[Any, str],
+    settings: Optional[dict[str, Any]],
     directory: str,
     include_uv_lock: bool = True,
 ) -> None:
@@ -50,7 +50,7 @@ async def upload_source_files_to_project(
         include_uv_lock=include_uv_lock,
     )
 
-    await sw_file_handler.upload_source_files(config_data)
+    await sw_file_handler.upload_source_files(settings)
 
 
 @click.command()
@@ -99,7 +99,7 @@ def push(root: str, nolock: bool) -> None:
             asyncio.run(
                 upload_source_files_to_project(
                     os.getenv(UIPATH_PROJECT_ID),
-                    config,
+                    config.get("settings", {}),
                     root,
                     include_uv_lock=not nolock,
                 )

uipath/_cli/models/runtime_schema.py

@@ -0,0 +1,71 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+COMMON_MODEL_SCHEMA = ConfigDict(
+    validate_by_name=True,
+    validate_by_alias=True,
+    use_enum_values=True,
+    arbitrary_types_allowed=True,
+    extra="allow",
+)
+
+
+class Entrypoint(BaseModel):
+    file_path: str = Field(..., alias="filePath")
+    unique_id: str = Field(..., alias="uniqueId")
+    type: str = Field(..., alias="type")
+    input: Dict[str, Any] = Field(..., alias="input")
+    output: Dict[str, Any] = Field(..., alias="output")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class BindingResourceValue(BaseModel):
+    default_value: str = Field(..., alias="defaultValue")
+    is_expression: bool = Field(..., alias="isExpression")
+    display_name: str = Field(..., alias="displayName")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+# TODO: create stronger binding resource definition with discriminator based on resource enum.
+class BindingResource(BaseModel):
+    resource: str = Field(..., alias="resource")
+    key: str = Field(..., alias="key")
+    value: dict[str, BindingResourceValue] = Field(..., alias="value")
+    metadata: Any = Field(..., alias="metadata")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class Bindings(BaseModel):
+    version: str = Field(..., alias="version")
+    resources: List[BindingResource] = Field(..., alias="resources")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeInternalArguments(BaseModel):
+    resource_overwrites: dict[str, Any] = Field(..., alias="resourceOverwrites")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeArguments(BaseModel):
+    internal_arguments: Optional[RuntimeInternalArguments] = Field(
+        default=None, alias="internalArguments"
+    )
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeSchema(BaseModel):
+    runtime: Optional[RuntimeArguments] = Field(default=None, alias="runtime")
+    entrypoints: List[Entrypoint] = Field(..., alias="entryPoints")
+    bindings: Bindings = Field(
+        default=Bindings(version="2.0", resources=[]), alias="bindings"
+    )
+    settings: Optional[Dict[str, Any]] = Field(default=None, alias="setting")
+
+    model_config = COMMON_MODEL_SCHEMA