uipath 2.1.88__tar.gz → 2.1.89__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.88"
+version = "2.1.89"
 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.88 → uipath-2.1.89}/src/uipath/_cli/_evals/_models/_evaluation_set.py

@@ -44,6 +44,15 @@ class LLMMockingStrategy(BaseMockingStrategy):
     )
 
 
+class InputMockingStrategy(BaseModel):
+    prompt: str = Field(..., alias="prompt")
+    model: Optional[ModelSettings] = Field(None, alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
 class MockingArgument(BaseModel):
     args: List[Any] = Field(default_factory=lambda: [], alias="args")
     kwargs: Dict[str, Any] = Field(default_factory=lambda: {}, alias="kwargs")
@@ -110,6 +119,10 @@ class EvaluationItem(BaseModel):
         default=None,
         alias="mockingStrategy",
     )
+    input_mocking_strategy: Optional[InputMockingStrategy] = Field(
+        default=None,
+        alias="inputMockingStrategy",
+    )
 
 
 class EvaluationSet(BaseModel):

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/_evals/_runtime.py

@@ -11,6 +11,10 @@ from opentelemetry import context as context_api
 from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
+from uipath._cli._evals.mocks.input_mocker import (
+    generate_llm_input,
+)
+
 from ..._events._event_bus import EventBus
 from ..._events._events import (
     EvalItemExceptionDetails,
@@ -318,6 +322,10 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         evaluators: List[BaseEvaluator[Any]],
         event_bus: EventBus,
     ) -> EvaluationRunResult:
+        # Generate LLM-based input if input_mocking_strategy is defined
+        if eval_item.input_mocking_strategy:
+            eval_item = await self._generate_input_for_eval(eval_item)
+
         set_execution_context(eval_item, self.span_collector)
 
         await event_bus.publish(
@@ -417,6 +425,16 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
         return evaluation_run_results
 
+    async def _generate_input_for_eval(
+        self, eval_item: EvaluationItem
+    ) -> EvaluationItem:
+        """Use LLM to generate a mock input for an evaluation item."""
+        # TODO(bai): get the input schema from agent definition, once it is available there.
+        input_schema: dict[str, Any] = {}
+        generated_input = await generate_llm_input(eval_item, input_schema)
+        updated_eval_item = eval_item.model_copy(update={"inputs": generated_input})
+        return updated_eval_item
+
     def _get_and_clear_execution_data(
         self, execution_id: str
     ) -> tuple[List[ReadableSpan], list[logging.LogRecord]]:

uipath-2.1.89/src/uipath/_cli/_evals/mocks/input_mocker.py

@@ -0,0 +1,111 @@
+"""LLM Input Mocker implementation."""
+
+import json
+from datetime import datetime
+from typing import Any, Dict
+
+from uipath import UiPath
+from uipath._cli._evals._models._evaluation_set import EvaluationItem
+from uipath.tracing._traced import traced
+
+from .mocker import UiPathInputMockingError
+
+
+def get_input_mocking_prompt(
+    input_schema: str,
+    input_generation_instructions: str,
+    expected_behavior: str,
+    expected_output: str,
+) -> str:
+    """Generate the LLM input mocking prompt."""
+    current_datetime = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+
+    return f"""You are simulating input for automated testing purposes of an Agent as part of a simulation run.
+You will need to generate realistic input to a LLM agent which will call various tools to achieve a goal. This must be in the exact format of the INPUT_SCHEMA.
+You may need to follow specific INPUT_GENERATION_INSTRUCTIONS. If no relevant instructions are provided pertaining to input generation, use the other provided information and your own judgement to generate input.
+If the INPUT_GENERATION_INSTRUCTIONS are provided, you MUST follow them exactly. For example if the instructions say to generate a value for a field to be before a certain calendar date, you must generate a value that is before that date.
+
+The current date and time is: {current_datetime}
+
+#INPUT_SCHEMA: You MUST OUTPUT THIS EXACT JSON SCHEMA
+{input_schema}
+#END_INPUT_SCHEMA
+
+#INPUT_GENERATION_INSTRUCTIONS
+{input_generation_instructions}
+#END_INPUT_GENERATION_INSTRUCTIONS
+
+#EXPECTED_BEHAVIOR
+{expected_behavior}
+#END_EXPECTED_BEHAVIOR
+
+#EXPECTED_OUTPUT
+{expected_output}
+#END_EXPECTED_OUTPUT
+
+Based on the above information, provide a realistic input to the LLM agent. Your response should:
+1. Match the expected input format according to the INPUT_SCHEMA exactly
+2. Be consistent with the style and level of detail in the example inputs
+3. Consider the context of the the agent being tested
+4. Be realistic and representative of what a real user might say or ask
+
+OUTPUT: ONLY the simulated agent input in the exact format of the INPUT_SCHEMA in valid JSON. Do not include any explanations, quotation marks, or markdown."""
+
+
+@traced(name="__mocker__")
+async def generate_llm_input(
+    evaluation_item: EvaluationItem,
+    input_schema: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Generate synthetic input using an LLM based on the evaluation context."""
+    try:
+        llm = UiPath().llm
+
+        prompt = get_input_mocking_prompt(
+            input_schema=json.dumps(input_schema, indent=2),
+            input_generation_instructions=evaluation_item.input_mocking_strategy.prompt
+            if evaluation_item.input_mocking_strategy
+            else "",
+            expected_behavior=evaluation_item.expected_agent_behavior or "",
+            expected_output=json.dumps(evaluation_item.expected_output, indent=2)
+            if evaluation_item.expected_output
+            else "",
+        )
+
+        response_format = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": "agent_input",
+                "strict": True,
+                "schema": input_schema,
+            },
+        }
+
+        model_parameters = (
+            evaluation_item.input_mocking_strategy.model
+            if evaluation_item.input_mocking_strategy
+            else None
+        )
+        completion_kwargs = (
+            model_parameters.model_dump(by_alias=False, exclude_none=True)
+            if model_parameters
+            else {}
+        )
+
+        response = await llm.chat_completions(
+            [{"role": "user", "content": prompt}],
+            response_format=response_format,
+            **completion_kwargs,
+        )
+
+        generated_input_str = response.choices[0].message.content
+
+        return json.loads(generated_input_str)
+    except json.JSONDecodeError as e:
+        raise UiPathInputMockingError(
+            f"Failed to parse LLM response as JSON: {str(e)}"
+        ) from e
+    except UiPathInputMockingError:
+        raise
+    except Exception as e:
+        raise UiPathInputMockingError(f"Failed to generate input: {str(e)}") from e

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/_evals/mocks/mocker.py

@@ -33,3 +33,9 @@ class UiPathMockResponseGenerationError(Exception):
     """Exception when a mocker is configured unable to generate a response."""
 
     pass
+
+
+class UiPathInputMockingError(Exception):
+    """Exception when input mocking fails."""
+
+    pass

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/_push/sw_file_handler.py

@@ -1,14 +1,12 @@
 """Studio Web File Handler for managing file operations in UiPath projects."""
 
 import json
+import logging
 import os
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, Set
 
-import click
-
 from ...models.exceptions import EnrichedException
-from .._utils._console import ConsoleLogger
 from .._utils._constants import (
     AGENT_INITIAL_CODE_VERSION,
     AGENT_STORAGE_VERSION,
@@ -30,6 +28,8 @@ from .._utils._studio_project import (
     StudioClient,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class SwFileHandler:
     """Handler for Studio Web file operations.
@@ -58,7 +58,6 @@ class SwFileHandler:
         """
         self.directory = directory
         self.include_uv_lock = include_uv_lock
-        self.console = ConsoleLogger()
         self._studio_client = StudioClient(project_id)
         self._project_structure: Optional[ProjectStructure] = None
 
@@ -156,9 +155,7 @@ class SwFileHandler:
 
         for local_file in local_files:
             if not os.path.exists(local_file.file_path):
-                self.console.warning(
-                    f"File not found: {click.style(local_file.file_path, fg='cyan')}"
-                )
+                logger.info(f"File not found: '{local_file.file_path}'")
                 continue
 
             # Skip agent.json as it's handled separately
@@ -175,9 +172,7 @@ class SwFileHandler:
                         id=remote_file.id, content_file_path=local_file.file_path
                     )
                 )
-                self.console.info(
-                    f"Updating {click.style(local_file.file_name, fg='yellow')}"
-                )
+                logger.info(f"Updating '{local_file.file_name}'")
             else:
                 parent_path = os.path.dirname(local_file.relative_path)
                 structural_migration.added_resources.append(
@@ -188,9 +183,7 @@ class SwFileHandler:
                         else "source_code",
                     )
                 )
-                self.console.info(
-                    f"Uploading {click.style(local_file.relative_path, fg='cyan')}"
-                )
+                logger.info(f"Uploading '{local_file.relative_path}'")
 
         # identify and add deleted files
         structural_migration.deleted_resources.extend(
@@ -236,9 +229,7 @@ class SwFileHandler:
         for _, remote_file in source_code_files.items():
             if remote_file.id not in processed_source_file_paths:
                 deleted_files.add(remote_file.id)
-                self.console.info(
-                    f"Deleting {click.style(remote_file.name, fg='bright_red')}"
-                )
+                logger.info(f"Deleting '{remote_file.name}'")
 
         return deleted_files
 
@@ -263,16 +254,14 @@ class SwFileHandler:
             for folder_info in empty_folder_ids:
                 try:
                     await self._studio_client.delete_item_async(folder_info["id"])
-                    self.console.info(
-                        f"Deleted empty folder {click.style(folder_info['name'], fg='bright_red')}"
-                    )
+                    logger.info(f"Deleted empty folder '{folder_info['name']}'")
                 except Exception as e:
-                    self.console.warning(
-                        f"Failed to delete empty folder {folder_info['name']}: {str(e)}"
+                    logger.warning(
+                        f"Failed to delete empty folder '{folder_info['name']}': {str(e)}"
                     )
 
         except Exception as e:
-            self.console.warning(f"Failed to cleanup empty folders: {str(e)}")
+            logger.warning(f"Failed to cleanup empty folders: {str(e)}")
 
     def _collect_empty_folders(self, folder: ProjectFolder) -> list[dict[str, str]]:
         """Recursively collect IDs and names of empty folders.
@@ -335,8 +324,8 @@ class SwFileHandler:
                 entry_points_json["entryPoints"] = uipath_config["entryPoints"]
 
             except Exception:
-                self.console.warning(
-                    "Could not parse existing entry-points.json file, using default version"
+                logger.info(
+                    "Could not parse existing 'entry-points.json' file, using default version"
                 )
             structural_migration.modified_resources.append(
                 ModifiedResource(
@@ -344,12 +333,10 @@ class SwFileHandler:
                     content_string=json.dumps(entry_points_json),
                 )
             )
-            self.console.info(
-                f"Updating {click.style('entry-points.json', fg='yellow')}"
-            )
+            logger.info("Updating 'entry-points.json'")
 
         else:
-            self.console.warning(
+            logger.info(
                 "'entry-points.json' file does not exist in Studio Web project, initializing using default version"
             )
             entry_points_json = {
@@ -363,9 +350,7 @@ class SwFileHandler:
                     content_string=json.dumps(entry_points_json),
                 )
             )
-            self.console.info(
-                f"Uploading {click.style('entry-points.json', fg='cyan')}"
-            )
+            logger.info("Uploading 'entry-points.json'")
 
     async def _prepare_agent_json_migration(
         self,
@@ -400,9 +385,10 @@ class SwFileHandler:
             input_schema = uipath_config["entryPoints"][0]["input"]
             output_schema = uipath_config["entryPoints"][0]["output"]
         except (FileNotFoundError, KeyError) as e:
-            self.console.error(
+            logger.error(
                 f"Unable to extract entrypoints from configuration file. Please run 'uipath init' : {str(e)}",
             )
+            return
 
         author = get_author_from_token_or_toml()
 
@@ -444,8 +430,8 @@ class SwFileHandler:
                         AGENT_INITIAL_CODE_VERSION[:-1] + "1"
                     )
             except Exception:
-                self.console.warning(
-                    "Could not parse existing agent.json file, using default version"
+                logger.info(
+                    "Could not parse existing 'agent.json' file, using default version"
                 )
 
             structural_migration.modified_resources.append(
@@ -454,9 +440,9 @@ class SwFileHandler:
                     content_string=json.dumps(agent_json),
                 )
             )
-            self.console.info(f"Updating {click.style('agent.json', fg='yellow')}")
+            logger.info("Updating 'agent.json'")
         else:
-            self.console.warning(
+            logger.info(
                 "'agent.json' file does not exist in Studio Web project, initializing using default version"
             )
             structural_migration.added_resources.append(
@@ -465,7 +451,7 @@ class SwFileHandler:
                     content_string=json.dumps(agent_json),
                 )
             )
-            self.console.info(f"Uploading {click.style('agent.json', fg='cyan')}")
+            logger.info("Uploading 'agent.json'")
 
     async def upload_source_files(self, config_data: dict[str, Any]) -> None:
         """Main method to upload source files to the UiPath project.
@@ -502,9 +488,7 @@ class SwFileHandler:
         if not source_code_folder:
             await self._studio_client.create_folder_async("source_code")
 
-            self.console.success(
-                f"Created {click.style('source_code', fg='cyan')} folder"
-            )
+            logger.info("Created 'source_code' folder.")
             source_code_files = {}
 
         # Get files to upload and process them

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/_runtime/_logging.py

@@ -266,6 +266,10 @@ class LogsInterceptor:
             def writable(self) -> bool:
                 return True
 
+            def __getattr__(self, name):
+                # Delegate any unknown attributes to the original file
+                return getattr(self.sys_file, name)
+
         # Set up stdout and stderr loggers
         stdout_logger = logging.getLogger("stdout")
         stderr_logger = logging.getLogger("stderr")

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/_utils/_project_files.py

@@ -1,12 +1,12 @@
 # type: ignore
 import hashlib
 import json
+import logging
 import os
 import re
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Protocol, Tuple
 
-import click
 from pydantic import BaseModel
 
 from .._utils._console import ConsoleLogger
@@ -22,6 +22,35 @@ try:
     import tomllib
 except ImportError:
     import tomli as tomllib
+logger = logging.getLogger(__name__)
+
+
+class FileConflictHandler(Protocol):
+    """Protocol for handling file conflicts."""
+
+    def should_overwrite(
+        self, file_path: str, local_hash: str, remote_hash: str
+    ) -> bool:
+        """Return True to overwrite, False to skip."""
+        ...
+
+
+class AlwaysOverwriteHandler:
+    """Handler that always overwrites files."""
+
+    def should_overwrite(
+        self, file_path: str, local_hash: str, remote_hash: str
+    ) -> bool:
+        return True
+
+
+class AlwaysSkipHandler:
+    """Handler that always skips conflicts."""
+
+    def should_overwrite(
+        self, file_path: str, local_hash: str, remote_hash: str
+    ) -> bool:
+        return False
 
 
 class FileInfo(BaseModel):
@@ -483,10 +512,37 @@ def collect_files_from_folder(
         collect_files_from_folder(subfolder, subfolder_path, files_dict)
 
 
+async def pull_project(
+    project_id: str,
+    download_configuration: dict[str, Path],
+    conflict_handler: Optional[FileConflictHandler] = None,
+):
+    """Pull project with configurable conflict handling."""
+    if conflict_handler is None:
+        conflict_handler = AlwaysOverwriteHandler()
+
+    studio_client = StudioClient(project_id)
+
+    try:
+        structure = await studio_client.get_project_structure_async()
+        for source_key, destination in download_configuration.items():
+            source_folder = get_folder_by_name(structure, source_key)
+            if source_folder:
+                await download_folder_files(
+                    studio_client, source_folder, destination, conflict_handler
+                )
+            else:
+                logger.warning(f"No '{source_key}' folder found in remote project")
+    except Exception:
+        logger.exception("Failed to pull UiPath project")
+        raise
+
+
 async def download_folder_files(
     studio_client: StudioClient,
     folder: ProjectFolder,
     base_path: Path,
+    conflict_handler: FileConflictHandler,
 ) -> None:
     """Download files from a folder recursively.
 
@@ -494,62 +550,36 @@ async def download_folder_files(
         studio_client: Studio client
         folder: The folder to download files from
         base_path: Base path for local file storage
+        conflict_handler: Handler for file conflicts
     """
     files_dict: Dict[str, ProjectFile] = {}
     collect_files_from_folder(folder, "", files_dict)
+
     for file_path, remote_file in files_dict.items():
         local_path = base_path / file_path
         local_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Download remote file
         response = await studio_client.download_file_async(remote_file.id)
         remote_content = response.read().decode("utf-8")
         remote_hash = compute_normalized_hash(remote_content)
 
         if os.path.exists(local_path):
-            # Read and hash local file
             with open(local_path, "r", encoding="utf-8") as f:
                 local_content = f.read()
                 local_hash = compute_normalized_hash(local_content)
 
-            # Compare hashes
             if local_hash != remote_hash:
-                styled_path = click.style(str(file_path), fg="cyan")
-                console.warning(f"File {styled_path}" + " differs from remote version.")
-                response = click.prompt("Do you want to overwrite it? (y/n)", type=str)
-                if response.lower() == "y":
+                if conflict_handler.should_overwrite(
+                    file_path, local_hash, remote_hash
+                ):
                     with open(local_path, "w", encoding="utf-8", newline="\n") as f:
                         f.write(remote_content)
-                    console.success(f"Updated {click.style(str(file_path), fg='cyan')}")
+                    logger.info(f"Updated '{file_path}'")
                 else:
-                    console.info(f"Skipped {click.style(str(file_path), fg='cyan')}")
+                    logger.info(f"Skipped '{file_path}'")
             else:
-                console.info(
-                    f"File {click.style(str(file_path), fg='cyan')} is up to date"
-                )
+                logger.info(f"File '{file_path}' is up to date")
         else:
-            # File doesn't exist locally, create it
             with open(local_path, "w", encoding="utf-8", newline="\n") as f:
                 f.write(remote_content)
-            console.success(f"Downloaded {click.style(str(file_path), fg='cyan')}")
-
-
-async def pull_project(project_id: str, download_configuration: dict[str, Path]):
-    studio_client = StudioClient(project_id)
-
-    with console.spinner("Pulling UiPath project files..."):
-        try:
-            structure = await studio_client.get_project_structure_async()
-            for source_key, destination in download_configuration.items():
-                source_folder = get_folder_by_name(structure, source_key)
-                if source_folder:
-                    await download_folder_files(
-                        studio_client,
-                        source_folder,
-                        destination,
-                    )
-                else:
-                    console.warning(f"No {source_key} folder found in remote project")
-
-        except Exception as e:
-            console.error(f"Failed to pull UiPath project: {str(e)}")
+            logger.info(f"Downloaded '{file_path}'")

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/_cli/cli_pull.py

@@ -24,6 +24,20 @@ from ._utils._project_files import pull_project
 console = ConsoleLogger()
 
 
+class InteractiveConflictHandler:
+    """Handler that prompts user for each conflict."""
+
+    def __init__(self, console: ConsoleLogger):
+        self.console = console
+
+    def should_overwrite(
+        self, file_path: str, local_hash: str, remote_hash: str
+    ) -> bool:
+        self.console.warning(f" File {file_path} differs from remote version.")
+        response = click.confirm("Do you want to overwrite it?", default=False)
+        return response
+
+
 @click.command()
 @click.argument(
     "root",
@@ -56,4 +70,11 @@ def pull(root: Path) -> None:
         "source_code": root,
         "evals": root / "evals",
     }
-    asyncio.run(pull_project(project_id, default_download_configuration))
+    with console.spinner("Pulling UiPath project files..."):
+        asyncio.run(
+            pull_project(
+                project_id,
+                default_download_configuration,
+                InteractiveConflictHandler(console),
+            )
+        )

{uipath-2.1.88 → uipath-2.1.89}/src/uipath/agent/_utils.py

@@ -4,7 +4,10 @@ from pathlib import PurePath
 from httpx import Response
 from pydantic import TypeAdapter
 
-from uipath._cli._evals._models._evaluation_set import LLMMockingStrategy
+from uipath._cli._evals._models._evaluation_set import (
+    InputMockingStrategy,
+    LLMMockingStrategy,
+)
 from uipath._cli._push.sw_file_handler import SwFileHandler
 from uipath._cli._utils._studio_project import (
     ProjectFile,
@@ -137,4 +140,14 @@ async def load_agent_definition(project_id: str) -> AgentDefinition:
                             evaluation.mocking_strategy = LLMMockingStrategy(
                                 prompt=prompt, tools_to_simulate=tools_to_simulate
                             )
+
+                    if not evaluation.input_mocking_strategy:
+                        # Migrate lowCode input mocking fields
+                        if evaluation.model_extra.get("simulateInput", False):
+                            prompt = evaluation.model_extra.get(
+                                "inputGenerationInstructions",
+                            )
+                            evaluation.input_mocking_strategy = InputMockingStrategy(
+                                prompt=prompt
+                            )
     return agent_definition

uipath-2.1.89/src/uipath/agent/loop/__init__.py

@@ -0,0 +1,17 @@
+"""LowCode Agent Loop Constructs.
+
+This module includes agentic loop constructs specific to LowCode Agent
+such as prompts, tools
+"""
+
+from uipath.agent.loop.prompts import AGENT_SYSTEM_PROMPT_TEMPLATE
+from uipath.agent.loop.tools import (
+    EndExecutionToolSchemaModel,
+    RaiseErrorToolSchemaModel,
+)
+
+__all__ = [
+    "AGENT_SYSTEM_PROMPT_TEMPLATE",
+    "EndExecutionToolSchemaModel",
+    "RaiseErrorToolSchemaModel",
+]