uipath 2.1.89__tar.gz → 2.1.91__tar.gz

{uipath-2.1.89 → uipath-2.1.91}/PKG-INFO

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

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

{uipath-2.1.89 → uipath-2.1.91}/samples/calculator/uipath.json

@@ -2,7 +2,7 @@
     "entryPoints": [
         {
             "filePath": "main.py",
-            "uniqueId": "cb9d5d2b-1f16-420f-baeb-cf3d80269248",
+            "uniqueId": "f62a1945-cb6f-48b2-b575-9d802e3f90c1",
             "type": "agent",
             "input": {
                 "type": "object",
@@ -47,4 +47,4 @@
         "version": "2.0",
         "resources": []
     }
-}
+}

{uipath-2.1.89 → uipath-2.1.91}/scripts/update_agents_md.py

@@ -1,10 +1,9 @@
 #!/usr/bin/env python3
-"""Script to update AGENTS.md with complete library documentation.
+"""Script to update AGENTS.md reference files with complete library documentation.
 
 This script extracts information from the uipath SDK and CLI commands and updates
-the AGENTS.md file with comprehensive documentation including
-- SDK version
-- Quick API Reference (SDK services and methods)
+the AGENTS.md reference files with comprehensive documentation including
+- API Reference (SDK services and methods)
 - CLI Commands Reference
 """
 
@@ -147,101 +146,8 @@ def get_service_methods(service_class: type) -> list[tuple[str, Any]]:
     return methods
 
 
-def generate_required_structure() -> str:
-    """Generate Required Agent Structure documentation.
-
-    Returns:
-        Markdown string with required agent structure
-    """
-    output = StringIO()
-    output.write("\n## Required Agent Structure\n\n")
-    output.write(
-        "**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.\n\n"
-    )
-
-    output.write("### Required Components\n\n")
-    output.write(
-        "Every agent implementation MUST include these three Pydantic models:\n\n"
-    )
-    output.write("```python\n")
-    output.write("from pydantic import BaseModel\n\n")
-    output.write("class Input(BaseModel):\n")
-    output.write('    """Define input fields that the agent accepts"""\n')
-    output.write("    # Add your input fields here\n")
-    output.write("    pass\n\n")
-    output.write("class State(BaseModel):\n")
-    output.write(
-        '    """Define the agent\'s internal state that flows between nodes"""\n'
-    )
-    output.write("    # Add your state fields here\n")
-    output.write("    pass\n\n")
-    output.write("class Output(BaseModel):\n")
-    output.write('    """Define output fields that the agent returns"""\n')
-    output.write("    # Add your output fields here\n")
-    output.write("    pass\n")
-    output.write("```\n\n")
-
-    output.write("### Required LLM Initialization\n\n")
-    output.write(
-        "Unless the user explicitly requests a different LLM provider, always use `UiPathChat`:\n\n"
-    )
-    output.write("```python\n")
-    output.write("from uipath_langchain.chat import UiPathChat\n\n")
-    output.write('llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)\n')
-    output.write("```\n\n")
-    output.write("**Alternative LLMs** (only use if explicitly requested):\n")
-    output.write("- `ChatOpenAI` from `langchain_openai`\n")
-    output.write("- `ChatAnthropic` from `langchain_anthropic`\n")
-    output.write("- Other LangChain-compatible LLMs\n\n")
-
-    output.write("### Standard Agent Template\n\n")
-    output.write("Every agent should follow this basic structure:\n\n")
-    output.write("```python\n")
-    output.write("from langchain_core.messages import SystemMessage, HumanMessage\n")
-    output.write("from langgraph.graph import START, StateGraph, END\n")
-    output.write("from uipath_langchain.chat import UiPathChat\n")
-    output.write("from pydantic import BaseModel\n\n")
-    output.write("# 1. Define Input, State, and Output models\n")
-    output.write("class Input(BaseModel):\n")
-    output.write("    field: str\n\n")
-    output.write("class State(BaseModel):\n")
-    output.write("    field: str\n")
-    output.write('    result: str = ""\n\n')
-    output.write("class Output(BaseModel):\n")
-    output.write("    result: str\n\n")
-    output.write("# 2. Initialize UiPathChat LLM\n")
-    output.write('llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)\n\n')
-    output.write("# 3. Define agent nodes (async functions)\n")
-    output.write("async def process_node(state: State) -> State:\n")
-    output.write("    response = await llm.ainvoke([HumanMessage(state.field)])\n")
-    output.write("    return State(field=state.field, result=response.content)\n\n")
-    output.write("async def output_node(state: State) -> Output:\n")
-    output.write("    return Output(result=state.result)\n\n")
-    output.write("# 4. Build the graph\n")
-    output.write("builder = StateGraph(State, input=Input, output=Output)\n")
-    output.write('builder.add_node("process", process_node)\n')
-    output.write('builder.add_node("output", output_node)\n')
-    output.write('builder.add_edge(START, "process")\n')
-    output.write('builder.add_edge("process", "output")\n')
-    output.write('builder.add_edge("output", END)\n\n')
-    output.write("# 5. Compile the graph\n")
-    output.write("graph = builder.compile()\n")
-    output.write("```\n\n")
-
-    output.write("**Key Rules**:\n")
-    output.write("1. Always use async/await for all node functions\n")
-    output.write("2. All nodes (except output) must accept and return `State`\n")
-    output.write("3. The final output node must return `Output`\n")
-    output.write(
-        "4. Use `StateGraph(State, input=Input, output=Output)` for initialization\n"
-    )
-    output.write("5. Always compile with `graph = builder.compile()`\n\n")
-
-    return output.getvalue()
-
-
 def generate_quick_api_docs() -> str:
-    """Generate Quick API Reference documentation for SDK.
+    """Generate API Reference documentation for SDK.
 
     Returns:
         Markdown string with SDK API documentation
@@ -249,7 +155,7 @@ def generate_quick_api_docs() -> str:
     from uipath import UiPath
 
     output = StringIO()
-    output.write("\n## Quick API Reference\n\n")
+    output.write("\n## API Reference\n\n")
     output.write(
         "This section provides a comprehensive reference for all UiPath SDK services and methods. "
         "Each service is documented with complete method signatures, including parameter types and return types.\n\n"
@@ -567,103 +473,29 @@ def generate_cli_docs() -> str:
     return output.getvalue()
 
 
-def update_agents_md() -> None:
-    """Update the AGENTS.md file and generate separate reference files."""
+def generate_agents_md_reference_files() -> None:
+    """Generate separate reference files."""
     resources_dir = Path(__file__).parent.parent / "src" / "uipath" / "_resources"
-    agents_md_path = resources_dir / "AGENTS.md"
 
-    if not agents_md_path.exists():
-        print(f"Error: AGENTS.md not found at {agents_md_path}", file=sys.stderr)
-        sys.exit(1)
-
-    with open(agents_md_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    required_structure_marker = "## Required Agent Structure"
-    api_marker = "## Quick API Reference"
-    cli_marker = "## CLI Commands Reference"
-    reference_marker = "## Documentation Structure"
-
-    if reference_marker in content:
-        header = content.split(reference_marker)[0].rstrip()
-    elif required_structure_marker in content:
-        header = content.split(required_structure_marker)[0].rstrip()
-    elif api_marker in content:
-        header = content.split(api_marker)[0].rstrip()
-    elif cli_marker in content:
-        header = content.split(cli_marker)[0].rstrip()
-    else:
-        header = content.rstrip()
-
-    required_structure_path = resources_dir / "REQUIRED_STRUCTURE.md"
     sdk_reference_path = resources_dir / "SDK_REFERENCE.md"
     cli_reference_path = resources_dir / "CLI_REFERENCE.md"
 
-    required_structure = generate_required_structure()
     api_docs = generate_quick_api_docs()
     cli_docs = generate_cli_docs()
 
-    with open(required_structure_path, "w", encoding="utf-8") as f:
-        f.write(required_structure.lstrip("\n"))
-
     with open(sdk_reference_path, "w", encoding="utf-8") as f:
         f.write(api_docs.lstrip("\n"))
 
     with open(cli_reference_path, "w", encoding="utf-8") as f:
         f.write(cli_docs.lstrip("\n"))
 
-    updated_content = f"""{header}
-
-## Documentation Structure
-
-This documentation is split into multiple files for efficient context loading. Load only the files you need:
-
-### Core Documentation Files
-
-1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
-   - **When to load:** Creating a new agent or understanding required patterns
-   - **Contains:** Required Pydantic models (Input, State, Output), LLM initialization patterns, standard agent template
-   - **Size:** ~90 lines
-
-2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
-   - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
-   - **Contains:** All SDK services and methods with full signatures and type annotations
-   - **Size:** ~400 lines
-
-3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
-   - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
-   - **Contains:** Command syntax, options, usage examples, and workflows
-   - **Size:** ~200 lines
-
-### Usage Guidelines
-
-**For LLMs:**
-- Read this file (AGENTS.md) first to understand the documentation structure
-- Load .agent/REQUIRED_STRUCTURE.md when building new agents or need structure reference
-- Load .agent/SDK_REFERENCE.md only when you need to call specific SDK methods
-- Load .agent/CLI_REFERENCE.md only when working with CLI commands
-
-**Benefits:**
-- Reduced token usage by loading only relevant context
-- Faster response times
-- More focused context for specific tasks
-"""
-
-    with open(agents_md_path, "w", encoding="utf-8") as f:
-        f.write(updated_content)
-
-    print(f"Successfully updated {agents_md_path}")
-    print(f"Generated {required_structure_path}")
-    print(f"Generated {sdk_reference_path}")
-    print(f"Generated {cli_reference_path}")
-
 
 def main():
     """Main function."""
     try:
-        update_agents_md()
+        generate_agents_md_reference_files()
     except Exception as e:
-        print(f"Error updating AGENTS.md: {e}", file=sys.stderr)
+        print(f"Error updating AGENTS.md reference files: {e}", file=sys.stderr)
         sys.exit(1)
 
 

{uipath-2.1.89 → uipath-2.1.91}/src/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-2.1.89 → uipath-2.1.91}/src/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-2.1.89 → uipath-2.1.91}/src/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-2.1.89 → uipath-2.1.91}/src/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-2.1.89 → uipath-2.1.91}/src/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-2.1.89 → uipath-2.1.91}/src/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: