uipath 2.1.90__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__)
@@ -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:

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

uipath/agent/models/agent.py

@@ -3,11 +3,8 @@
 from enum import Enum
 from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag, field_validator
 
-from uipath._cli._evals._models._evaluation_set import EvaluationSet
-from uipath._cli._evals._models._evaluator import Evaluator
-from uipath._cli._evals._models._mocks import ExampleCall
 from uipath.models import Connection
 
 
@@ -17,6 +14,7 @@ class AgentResourceType(str, Enum):
     TOOL = "tool"
     CONTEXT = "context"
     ESCALATION = "escalation"
+    MCP = "mcp"
 
 
 class BaseAgentResourceConfig(BaseModel):
@@ -55,12 +53,14 @@ class AgentToolType(str, Enum):
     """Agent tool type."""
 
     AGENT = "agent"
-    INTEGRATION = "integration"
     PROCESS = "process"
+    API = "api"
+    PROCESS_ORCHESTRATION = "processorchestration"
+    INTEGRATION = "integration"
 
 
 class AgentToolSettings(BaseModel):
-    """Settings for tool configuration."""
+    """Settings for tool."""
 
     max_attempts: Optional[int] = Field(None, alias="maxAttempts")
     retry_delay: Optional[int] = Field(None, alias="retryDelay")
@@ -74,7 +74,9 @@ class AgentToolSettings(BaseModel):
 class BaseResourceProperties(BaseModel):
     """Base resource properties."""
 
-    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
 
 
 class AgentProcessToolProperties(BaseResourceProperties):
@@ -91,7 +93,12 @@ class AgentProcessToolProperties(BaseResourceProperties):
 class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
     """Tool resource with tool-specific properties."""
 
-    type: Literal[AgentToolType.AGENT] = AgentToolType.AGENT
+    type: Literal[
+        AgentToolType.AGENT,
+        AgentToolType.PROCESS,
+        AgentToolType.API,
+        AgentToolType.PROCESS_ORCHESTRATION,
+    ]
     output_schema: Dict[str, Any] = Field(
         ..., alias="outputSchema", description="Output schema for the tool"
     )
@@ -101,6 +108,17 @@ class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
     settings: AgentToolSettings = Field(
         default_factory=AgentToolSettings, description="Tool settings"
     )
+    arguments: Dict[str, Any] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize tool type to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -133,7 +151,7 @@ class AgentIntegrationToolParameter(BaseModel):
 
 
 class AgentIntegrationToolProperties(BaseResourceProperties):
-    """Properties specific to tool configuration."""
+    """Properties specific to tool."""
 
     tool_path: str = Field(..., alias="toolPath")
     object_name: str = Field(..., alias="objectName")
@@ -141,7 +159,7 @@ class AgentIntegrationToolProperties(BaseResourceProperties):
     tool_description: str = Field(..., alias="toolDescription")
     method: str = Field(..., alias="method")
     connection: Connection = Field(..., alias="connection")
-    body_structure: dict[str, Any] = Field(..., alias="bodyStructure")
+    body_structure: Optional[dict[str, Any]] = Field(None, alias="bodyStructure")
     parameters: List[AgentIntegrationToolParameter] = Field([], alias="parameters")
 
     model_config = ConfigDict(
@@ -154,26 +172,93 @@ class AgentIntegrationToolResourceConfig(BaseAgentToolResourceConfig):
 
     type: Literal[AgentToolType.INTEGRATION] = AgentToolType.INTEGRATION
     properties: AgentIntegrationToolProperties
+    arguments: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize tool type to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
-class AgentUnknownToolResourceConfig(BaseAgentToolResourceConfig):
+class AgentUnknownToolResourceConfig(BaseAgentResourceConfig):
     """Fallback for unknown or future tool types."""
 
     resource_type: Literal[AgentResourceType.TOOL] = AgentResourceType.TOOL
     type: str = Field(alias="$resourceType")
+    arguments: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
 
     model_config = ConfigDict(extra="allow")
 
 
+class AgentContextQuerySetting(BaseModel):
+    """Query setting for context configuration."""
+
+    description: Optional[str] = Field(None)
+    variant: Optional[str] = Field(None)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentContextValueSetting(BaseModel):
+    """Generic value setting for context configuration."""
+
+    value: Any = Field(...)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentContextOutputColumn(BaseModel):
+    """Output column configuration for Batch Transform."""
+
+    name: str = Field(...)
+    description: Optional[str] = Field(None)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
 class AgentContextSettings(BaseModel):
-    """Settings for context configuration."""
+    """Settings for context."""
 
     result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured"] = Field(alias="retrievalMode")
+    retrieval_mode: Literal["Semantic", "Structured", "DeepRAG", "BatchTransform"] = (
+        Field(alias="retrievalMode")
+    )
     threshold: float = Field(default=0)
+    query: Optional[AgentContextQuerySetting] = Field(None)
+    folder_path_prefix: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = (
+        Field(None, alias="folderPathPrefix")
+    )
+    file_extension: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = Field(
+        None, alias="fileExtension"
+    )
+    citation_mode: Optional[AgentContextValueSetting] = Field(
+        None, alias="citationMode"
+    )
+    web_search_grounding: Optional[AgentContextValueSetting] = Field(
+        None, alias="webSearchGrounding"
+    )
+    output_columns: Optional[List[AgentContextOutputColumn]] = Field(
+        None, alias="outputColumns"
+    )
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -187,19 +272,67 @@ class AgentContextResourceConfig(BaseAgentResourceConfig):
     folder_path: str = Field(alias="folderPath")
     index_name: str = Field(alias="indexName")
     settings: AgentContextSettings = Field(..., description="Context settings")
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentMcpTool(BaseModel):
+    """MCP available tool."""
+
+    name: str = Field(..., alias="name")
+    description: str = Field(..., alias="description")
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
+class AgentMcpResourceConfig(BaseAgentResourceConfig):
+    """MCP resource configuration."""
+
+    resource_type: Literal[AgentResourceType.MCP] = Field(alias="$resourceType")
+    folder_path: str = Field(alias="folderPath")
+    slug: str = Field(..., alias="slug")
+    available_tools: List[AgentMcpTool] = Field(..., alias="availableTools")
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentEscalationRecipientType(str, Enum):
+    """Enum for escalation recipient types."""
+
+    USER_ID = "UserId"
+    GROUP_ID = "GroupId"
+    USER_EMAIL = "UserEmail"
+
+
 class AgentEscalationRecipient(BaseModel):
     """Recipient for escalation."""
 
-    type: int = Field(..., alias="type")
+    type: Union[AgentEscalationRecipientType, str] = Field(..., alias="type")
     value: str = Field(..., alias="value")
     display_name: Optional[str] = Field(default=None, alias="displayName")
 
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize recipient type from int (1=UserId, 2=GroupId, 3=UserEmail) or string. Unknown integers are converted to string."""
+        if isinstance(v, int):
+            mapping = {
+                1: AgentEscalationRecipientType.USER_ID,
+                2: AgentEscalationRecipientType.GROUP_ID,
+                3: AgentEscalationRecipientType.USER_EMAIL,
+            }
+            return mapping.get(v, str(v))
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
@@ -227,7 +360,7 @@ class AgentEscalationChannelProperties(BaseResourceProperties):
 class AgentEscalationChannel(BaseModel):
     """Agent escalation channel."""
 
-    id: str = Field(..., alias="id")
+    id: Optional[str] = Field(None, alias="id")
     name: str = Field(..., alias="name")
     type: str = Field(alias="type")
     description: str = Field(..., alias="description")
@@ -239,8 +372,12 @@ class AgentEscalationChannel(BaseModel):
         alias="outputSchema",
         description="Output schema for the escalation channel",
     )
+    outcome_mapping: Optional[Dict[str, str]] = Field(None, alias="outcomeMapping")
     properties: AgentEscalationChannelProperties = Field(..., alias="properties")
     recipients: List[AgentEscalationRecipient] = Field(..., alias="recipients")
+    task_title: Optional[str] = Field(default=None, alias="taskTitle")
+    priority: Optional[str] = None
+    labels: List[str] = Field(default_factory=list)
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -250,11 +387,11 @@ class AgentEscalationChannel(BaseModel):
 class AgentEscalationResourceConfig(BaseAgentResourceConfig):
     """Escalation resource with escalation-specific properties."""
 
+    id: Optional[str] = Field(None, alias="id")
     resource_type: Literal[AgentResourceType.ESCALATION] = Field(alias="$resourceType")
     channels: List[AgentEscalationChannel] = Field(alias="channels")
-
-    # escalation_type: int = Field(..., alias="escalationType")
-    is_agent_memory_enabled: bool = Field(alias="isAgentMemoryEnabled")
+    is_agent_memory_enabled: bool = Field(default=False, alias="isAgentMemoryEnabled")
+    escalation_type: int = Field(default=0, alias="escalationType")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -269,9 +406,16 @@ def custom_discriminator(data: Any) -> str:
             return "AgentContextResourceConfig"
         elif resource_type == AgentResourceType.ESCALATION:
             return "AgentEscalationResourceConfig"
+        elif resource_type == AgentResourceType.MCP:
+            return "AgentMcpResourceConfig"
         elif resource_type == AgentResourceType.TOOL:
             tool_type = data.get("type")
-            if tool_type == AgentToolType.AGENT:
+            if tool_type in [
+                AgentToolType.AGENT,
+                AgentToolType.PROCESS,
+                AgentToolType.API,
+                AgentToolType.PROCESS_ORCHESTRATION,
+            ]:
                 return "AgentProcessToolResourceConfig"
             elif tool_type == AgentToolType.INTEGRATION:
                 return "AgentIntegrationToolResourceConfig"
@@ -296,47 +440,24 @@ AgentResourceConfig = Annotated[
         ],
         Annotated[AgentContextResourceConfig, Tag("AgentContextResourceConfig")],
         Annotated[AgentEscalationResourceConfig, Tag("AgentEscalationResourceConfig")],
+        Annotated[AgentMcpResourceConfig, Tag("AgentMcpResourceConfig")],
         Annotated[AgentUnknownResourceConfig, Tag("AgentUnknownResourceConfig")],
     ],
     Field(discriminator=Discriminator(custom_discriminator)),
 ]
 
 
-class BaseAgentDefinition(BaseModel):
-    """Main agent model."""
+class AgentMetadata(BaseModel):
+    """Metadata for agent."""
 
-    id: str = Field(..., description="Agent id or project name")
-    name: str = Field(..., description="Agent name or project name")
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="JSON schema for input arguments"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="JSON schema for output arguments"
-    )
-    version: str = Field("1.0.0", description="Agent version")
-    resources: List[AgentResourceConfig] = Field(
-        ..., description="List of tools, context, and escalation resources"
-    )
-    evaluation_sets: Optional[List[EvaluationSet]] = Field(
-        None,
-        alias="evaluationSets",
-        description="List of agent evaluation sets",
-    )
-    evaluators: Optional[List[Evaluator]] = Field(
-        None, description="List of agent evaluators"
-    )
+    is_conversational: bool = Field(alias="isConversational")
+    storage_version: str = Field(alias="storageVersion")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
-class AgentType(str, Enum):
-    """Agent type."""
-
-    LOW_CODE = "lowCode"
-
-
 class AgentMessageRole(str, Enum):
     """Enum for message roles."""
 
@@ -345,23 +466,31 @@ class AgentMessageRole(str, Enum):
 
 
 class AgentMessage(BaseModel):
-    """Message model for agent conversations."""
+    """Message model for agent definition."""
 
-    role: AgentMessageRole
+    role: Literal[AgentMessageRole.SYSTEM, AgentMessageRole.USER]
     content: str
 
+    @field_validator("role", mode="before")
+    @classmethod
+    def normalize_role(cls, v: Any) -> str:
+        """Normalize role to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
 class AgentSettings(BaseModel):
-    """Settings for agent configuration."""
+    """Settings for agent."""
 
     engine: str = Field(..., description="Engine type, e.g., 'basic-v1'")
-    model: str = Field(..., description="LLM model identifier")
+    model: str = Field(..., description="LLM model")
     max_tokens: int = Field(
-        ..., alias="maxTokens", description="Maximum number of tokens"
+        ..., alias="maxTokens", description="Maximum number of tokens per completion"
     )
     temperature: float = Field(..., description="Temperature for response generation")
 
@@ -370,17 +499,60 @@ class AgentSettings(BaseModel):
     )
 
 
+class BaseAgentDefinition(BaseModel):
+    """Agent definition model."""
+
+    input_schema: Dict[str, Any] = Field(
+        ..., alias="inputSchema", description="JSON schema for input arguments"
+    )
+    output_schema: Dict[str, Any] = Field(
+        ..., alias="outputSchema", description="JSON schema for output arguments"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentType(str, Enum):
+    """Agent type."""
+
+    LOW_CODE = "lowCode"
+    CODED = "coded"
+
+
 class LowCodeAgentDefinition(BaseAgentDefinition):
     """Low code agent definition."""
 
     type: Literal[AgentType.LOW_CODE] = AgentType.LOW_CODE
+
+    id: str = Field(..., description="Agent id or project name")
+    name: str = Field(..., description="Agent name or project name")
+    metadata: Optional[AgentMetadata] = Field(None, description="Agent metadata")
     messages: List[AgentMessage] = Field(
         ..., description="List of system and user messages"
     )
-    features: List[Any] = Field(
-        default_factory=list, description="Currently empty feature list"
+
+    version: str = Field("1.0.0", description="Agent version")
+    resources: List[AgentResourceConfig] = Field(
+        ..., description="List of tools, context, mcp and escalation resources"
+    )
+    features: List[Any] = Field(default_factory=list, description="Agent feature list")
+    settings: AgentSettings = Field(..., description="Agent settings")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class CodedAgentDefinition(BaseAgentDefinition):
+    """Coded agent definition."""
+
+    type: Literal[AgentType.CODED] = AgentType.CODED
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
     )
-    settings: AgentSettings = Field(..., description="Agent settings configuration")
 
 
 KnownAgentDefinition = Annotated[

uipath/agent/models/evals.py

@@ -0,0 +1,56 @@
+"""Agent Evaluation Models.
+
+These models extend the base agent models with evaluation and simulation-specific fields.
+"""
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from uipath._cli._evals._models._evaluation_set import EvaluationSet
+from uipath._cli._evals._models._evaluator import Evaluator
+from uipath._cli._evals._models._mocks import ExampleCall
+from uipath.agent.models.agent import (
+    AgentEscalationChannelProperties,
+    AgentIntegrationToolProperties,
+    AgentProcessToolProperties,
+    BaseResourceProperties,
+    LowCodeAgentDefinition,
+)
+
+
+class AgentEvalResourceProperties(BaseResourceProperties):
+    """Resource properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalProcessToolProperties(AgentProcessToolProperties):
+    """Process tool properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalIntegrationToolProperties(AgentIntegrationToolProperties):
+    """Integration tool properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalEscalationChannelProperties(AgentEscalationChannelProperties):
+    """Escalation channel properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalsDefinition(LowCodeAgentDefinition):
+    """Agent definition with evaluation sets and evaluators support."""
+
+    evaluation_sets: Optional[List[EvaluationSet]] = Field(
+        None,
+        alias="evaluationSets",
+        description="List of agent evaluation sets",
+    )
+    evaluators: Optional[List[Evaluator]] = Field(
+        None, description="List of agent evaluators"
+    )

uipath/telemetry/_track.py

@@ -95,6 +95,7 @@ class _TelemetryClient:
                 "service.name=uipath-sdk,service.instance.id=" + version("uipath")
             )
             os.environ["OTEL_TRACES_EXPORTER"] = "none"
+            os.environ["APPLICATIONINSIGHTS_STATSBEAT_DISABLED_ALL"] = "true"
 
             configure_azure_monitor(
                 connection_string=_CONNECTION_STRING,

{uipath-2.1.90.dist-info → uipath-2.1.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.90
+Version: 2.1.91
 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.90.dist-info → uipath-2.1.91.dist-info}/RECORD

@@ -10,13 +10,13 @@ uipath/_cli/cli_auth.py,sha256=CzetSRqSUvMs02PtI4w5Vi_0fv_ETA307bB2vXalWzY,2628
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
 uipath/_cli/cli_eval.py,sha256=oOMywGSUrHDQ1W_54ccbekzCeduPf-KHRyu_r0Dezd0,5444
-uipath/_cli/cli_init.py,sha256=AUBQxUO1LWC2W-MaydkJBlhsg1m-H7eiXqu5jNhTgPQ,7673
+uipath/_cli/cli_init.py,sha256=2OE9uF4uCEwOVE_MiPJGjEK0bCnlIjsBqOBHwB98X4c,7831
 uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,4395
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
-uipath/_cli/cli_pack.py,sha256=NmwZTfwZ2fURiHyiX1BM0juAtBOjPB1Jmcpu-rD7p-4,11025
+uipath/_cli/cli_pack.py,sha256=U5rXVbUnHFgdEsXyhkjmWza8dfob1wU9lyl4yrYnUss,11076
 uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,6471
 uipath/_cli/cli_pull.py,sha256=muX2gR-W-bSrNI3pIO0zbhZAP0VBOSsOY2-yrq8HgAw,2433
-uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
+uipath/_cli/cli_push.py,sha256=_JbjI45uJaobBDaz--NlzAXYJNwHX_XGLa8eC9wN-Cg,3166
 uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
 uipath/_cli/middlewares.py,sha256=0D9a-wphyetnH9T97F08o7-1OKWF1lMweFHHAR0xiOw,4979
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
@@ -46,7 +46,7 @@ uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=_ipTl_oAiMF9I7keGt2AAFAMz40D
 uipath/_cli/_evals/_console_progress_reporter.py,sha256=HgB6pdMyoS6YVwuI3EpM2LBcH3U69nrdaTyNgPG8ssg,9304
 uipath/_cli/_evals/_evaluator_factory.py,sha256=Gycv94VtGOpMir_Gba-UoiAyrSRfbSfe8_pTfjzcA9Q,3875
 uipath/_cli/_evals/_progress_reporter.py,sha256=kX7rNSa-QCLXIzK-vb9Jjf-XLEtucdeiQPgPlSkpp2U,16778
-uipath/_cli/_evals/_runtime.py,sha256=eK32s4yWOFsiwYBbe5bml02oNarKT6q7bkSalTuoodY,20608
+uipath/_cli/_evals/_runtime.py,sha256=JABvs_EhgG6qqpAsJcC2uTDRZw9JgYOhFrpejFGy2vA,20655
 uipath/_cli/_evals/_span_collection.py,sha256=RoKoeDFG2XODdlgI27ionCjU7LLD_C0LJJ3gu0wab10,779
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=0I83I3HNu_BrgFz9miar2QTyXKb0dAaEpYMQrKUHP0U,4958
 uipath/_cli/_evals/_models/_evaluator.py,sha256=fuC3UOYwPD4d_wdynHeLSCzbu82golNAnnPnxC8Y4rk,3315
@@ -57,12 +57,12 @@ uipath/_cli/_evals/_models/_output.py,sha256=4KPgXypO2qvWsDf37KbdMGmlYgaIfBSeGgK
 uipath/_cli/_evals/_models/_sw_reporting.py,sha256=tSBLQFAdOIun8eP0vsqt56K6bmCZz_uMaWI3hskg_24,536
 uipath/_cli/_evals/mocks/__init__.py,sha256=2WXwAy_oZw5bKp6L0HB13QygCJeftOB_Bget0AI6Gik,32
 uipath/_cli/_evals/mocks/input_mocker.py,sha256=imJLriJv1rFthoA-SnJewnNbN27yen8VP11vbv1I9-0,4150
-uipath/_cli/_evals/mocks/llm_mocker.py,sha256=VrjzkeOVAJNKfkrHntQ17MBEtHZhwszEzc_uuPH3Tbc,7355
+uipath/_cli/_evals/mocks/llm_mocker.py,sha256=36WO2lWHTtaAfunSAZ_CGgNPYZthszxDRBvqbPBzwdE,7517
 uipath/_cli/_evals/mocks/mocker.py,sha256=VXCxuRAPqUK40kRUXpPmXZRckd7GrOY5ZzIYDe-NNfo,910
 uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf2UC5mXqwuUGTs,811
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=AO2BmFwA6hz3Lte-STVr7aJDPvMCqKNKa4j2jeNZ_U4,2677
-uipath/_cli/_evals/mocks/mocks.py,sha256=jfenoCSnMPpaXEyAcRDVu5jIfb62eRredRenZDI_AzE,1965
-uipath/_cli/_push/sw_file_handler.py,sha256=gySENzKMcIDtE4u_MrXDK0g-h9wRz6jaJJht1LW54Nc,17877
+uipath/_cli/_evals/mocks/mocks.py,sha256=HY0IaSqqO8hioBB3rp5XwAjSpQE4K5hoH6oJQ-sH72I,2207
+uipath/_cli/_push/sw_file_handler.py,sha256=sPEopayYzjPNJA6fV9SZZtzE_cdHs1uSszh2IJTB35g,17874
 uipath/_cli/_runtime/_contracts.py,sha256=E8Is7EQfAu7_hCbeZI68gmTxSxo4X7_U4vcSl7D3Syg,28988
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
@@ -81,12 +81,14 @@ uipath/_cli/_utils/_debug.py,sha256=zamzIR4VgbdKADAE4gbmjxDsbgF7wvdr7C5Dqp744Oc,
 uipath/_cli/_utils/_eval_set.py,sha256=4aP8yAC-jMrNYaC62Yj8fHD2hNlotGwy63bciQrpdc4,2766
 uipath/_cli/_utils/_folders.py,sha256=RsYrXzF0NA1sPxgBoLkLlUY3jDNLg1V-Y8j71Q8a8HY,1357
 uipath/_cli/_utils/_input_args.py,sha256=AnbQ12D2ACIQFt0QHMaWleRn1ZgRTXuTSTN0ozJiSQg,5766
-uipath/_cli/_utils/_parse_ast.py,sha256=8Iohz58s6bYQ7rgWtOTjrEInLJ-ETikmOMZzZdIY2Co,20072
+uipath/_cli/_utils/_parse_ast.py,sha256=24YL28qK5Ss2O26IlzZ2FgEC_ZazXld_u3vkj8zVxGA,20933
 uipath/_cli/_utils/_processes.py,sha256=q7DfEKHISDWf3pngci5za_z0Pbnf_shWiYEcTOTCiyk,1855
-uipath/_cli/_utils/_project_files.py,sha256=ueDUGQrig5EFSgEXUiaXmMGAgs1b_tX2yBpgaXsHcrA,20093
+uipath/_cli/_utils/_project_files.py,sha256=_P42C8wJbN66gJYwt3yAnWsOMqbqFHv80kAoT8UGYuo,20112
 uipath/_cli/_utils/_studio_project.py,sha256=8WYwi_CiTPRqo8KV2bsvj0H_KBFxTEN0Q2cXoZb-NnM,17030
 uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4oo,1541
 uipath/_cli/_utils/_uv_helpers.py,sha256=6SvoLnZPoKIxW0sjMvD1-ENV_HOXDYzH34GjBqwT138,3450
+uipath/_cli/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath/_cli/models/runtime_schema.py,sha256=Po1SYFwTBlWZdmwIG2GvFy0WYbZnT5U1aGjfWcd8ZAA,2181
 uipath/_events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,5496
 uipath/_events/_events.py,sha256=EzDfzpVm-EIH27Onad5mo8Go6-WB3S6_-6zZQ7qV58w,1811
@@ -138,7 +140,8 @@ uipath/agent/conversation/tool.py,sha256=ol8XI8AVd-QNn5auXNBPcCzOkh9PPFtL7hTK3kq
 uipath/agent/loop/__init__.py,sha256=EZlNqrh8xod0VtTJqc-1pyUofaeS6PKjbsDfWoveVtI,424
 uipath/agent/loop/prompts.py,sha256=qPwyd6Ple2m-Kt0m2foa6ZEmxD3kyCXOmGfXvzHi8Rc,3372
 uipath/agent/loop/tools.py,sha256=OsT3x431KqOEzLi2jLxy2B9xXbcFq16xMfmyAqFaqZQ,1351
-uipath/agent/models/agent.py,sha256=18NvqLtuQoEHYnrHiEApWjaka91PYCj_fJRFE72z4Uw,13236
+uipath/agent/models/agent.py,sha256=dEUWZIzvTnxhdCQlMad6Pf6EphLP_W5ukHtczbXKYL0,18712
+uipath/agent/models/evals.py,sha256=QMIqwCuwabD_vYF0KgJpip5BV0pFLf9ZKUd9AL5eU2w,1843
 uipath/eval/_helpers/__init__.py,sha256=GSmZMryjuO3Wo_zdxZdrHCRRsgOxsVFYkYgJ15YNC3E,86
 uipath/eval/_helpers/helpers.py,sha256=iE2HHdMiAdAMLqxHkPKHpfecEtAuN5BTBqvKFTI8ciE,1315
 uipath/eval/evaluators/__init__.py,sha256=DJAAhgv0I5UfBod4sGnSiKerfrz1iMmk7GNFb71V8eI,494
@@ -173,7 +176,7 @@ uipath/models/processes.py,sha256=bV31xTyF0hRWZmwy3bWj5L8dBD9wttWxfJjwzhjETmk,19
 uipath/models/queues.py,sha256=gnbeEyYlHtdqdxBalio0lw8mq-78YBG9MPMSkv1BWOg,6934
 uipath/telemetry/__init__.py,sha256=Wna32UFzZR66D-RzTKlPWlvji9i2HJb82NhHjCCXRjY,61
 uipath/telemetry/_constants.py,sha256=uRDuEZayBYtBA0tMx-2AS_D-oiVA7oKgp9zid9jNats,763
-uipath/telemetry/_track.py,sha256=zD39zSs0sWsWnFkqf15xCLwFKu6Ic8CfjdPACTvIOoQ,4709
+uipath/telemetry/_track.py,sha256=3RZgJtY8y28Y5rfVmC432OyRu7N3pSxPouwa82KWFso,4787
 uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
 uipath/tracing/_otel_exporters.py,sha256=c0GKU_oUrAwrOrqbyu64c55z1TR6xk01d3y5fLUN1lU,3215
 uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,19901
@@ -181,8 +184,8 @@ uipath/tracing/_utils.py,sha256=X-LFsyIxDeNOGuHPvkb6T5o9Y8ElYhr_rP3CEBJSu4s,1383
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.90.dist-info/METADATA,sha256=GUdxOQ8RiDFdvNtyRByMvvA_q_Ionidg7VbtOEKzdQg,6593
-uipath-2.1.90.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.90.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.90.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.90.dist-info/RECORD,,
+uipath-2.1.91.dist-info/METADATA,sha256=4qk08PijcX8XCNXQJLdjg27DadfbidSqDiY5YWUc734,6593
+uipath-2.1.91.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.91.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.91.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.91.dist-info/RECORD,,