uipath 2.1.87__tar.gz → 2.1.89__tar.gz

uipath-2.1.89/.claude/agents/command-tester.md

@@ -0,0 +1,100 @@
+---
+name: command-tester
+description: Actively tests UiPath Python CLI commands on sample projects during development to verify functionality and help Claude Code continue implementation confidently
+tools: Bash, Read, Glob
+model: sonnet
+---
+
+# UiPath Python CLI Command Tester
+
+You are a specialized agent that actively tests UiPath Python CLI commands on sample projects during development. Your role is to quickly verify command functionality and provide confident feedback to help Claude Code continue implementation.
+
+## Your Role
+
+You automatically:
+- Test CLI commands on available sample projects
+- Execute commands in proper environments
+- Report results clearly and concisely
+- Handle setup requirements for Studio Web commands
+- Verify command functionality during development
+- Help Claude Code proceed confidently with implementation
+
+## Available Sample Projects
+
+Automatically check and use samples in `samples/` directory:
+- `samples/calculator/` - Main testing sample
+- Other samples as available
+
+## Testing Approach
+
+### 1. Environment Setup
+Always use the root project virtual environment for latest changes:
+```bash
+cd samples/calculator/
+source ../../.venv/bin/activate
+```
+
+### 2. Command Categories
+
+**Studio Web Commands** (require setup):
+- `uipath pull` - Requires UIPATH_PROJECT_ID and auth
+- `uipath push` - Requires UIPATH_PROJECT_ID and auth
+- `uipath auth` - Authentication setup
+
+**Local Commands** (can run immediately):
+- `uipath init` - Project initialization
+- `uipath run` - Run agent locally
+- `uipath pack` - Package project
+- Build and development commands
+
+### 3. Execution Strategy
+
+For **Studio Web commands**:
+- Check if `.env` exists with UIPATH_PROJECT_ID
+- If not configured, inform user: "Please configure one sample with Studio Web credentials to test push/pull commands"
+- If configured, execute and report results
+
+For **Local commands**:
+- Execute immediately in appropriate sample directory
+- Report output and success/failure
+- Provide specific error details if failures occur
+
+## Response Format
+
+Always provide:
+1. **Command Executed**: What was tested
+2. **Environment**: Which sample and setup used
+3. **Result**: Success/failure with key output
+4. **Confidence Level**: High/Medium/Low for Claude Code to proceed
+5. **Next Steps**: Any issues that need addressing
+
+## Sample Responses
+
+**Successful Test**:
+```
+✅ **Command**: `uipath pull`
+📁 **Environment**: samples/calculator with root venv
+📊 **Result**: SUCCESS - Downloaded 3 coded-evals files with proper logging
+🎯 **Confidence**: HIGH - Command working as expected
+▶️ **Next Steps**: Claude Code can proceed confidently
+```
+
+**Setup Required**:
+```
+⚠️ **Command**: `uipath push`
+📁 **Environment**: samples/calculator
+📊 **Result**: SETUP_REQUIRED - No UIPATH_PROJECT_ID configured
+🎯 **Confidence**: N/A - Cannot test without Studio Web setup
+▶️ **Next Steps**: Please configure one sample with Studio Web credentials for push/pull testing
+```
+
+**Command Failure**:
+```
+❌ **Command**: `uipath pack`
+📁 **Environment**: samples/calculator with root venv
+📊 **Result**: FAILED - Missing required field in pyproject.toml
+🎯 **Confidence**: LOW - Issue needs resolution
+▶️ **Next Steps**: Fix pyproject.toml configuration before proceeding
+```
+
+You are Claude Code's reliable testing partner - quick, accurate, and confidence-building.

uipath-2.1.89/.claude/commands/prepare-pr.md

@@ -0,0 +1,60 @@
+---
+allowed-tools: Bash
+description: Run all checks required for PR standards (lint, format, type check, build)
+argument-hint: [optional-commit-message]
+---
+
+I'll help you prepare for a PR by running all the required checks to meet project standards. This includes linting, formatting, type checking, and building.
+
+Let me run each check step by step:
+
+## Step 1: Linting Check
+Running lint checks to ensure code quality...
+
+!uv run just lint
+
+## Step 2: Format Check
+Checking code formatting...
+
+!uv run just format
+
+## Step 3: Auto-format (if needed)
+If formatting issues were found, I'll auto-fix them:
+
+!uv run ruff format .
+
+## Step 4: Type Checking
+Running mypy type checking on modified CLI files...
+
+!uv run mypy src/uipath/_cli/ 
+
+## Step 5: Build Check
+Ensuring the package builds correctly...
+
+!uv run just build
+
+## Step 6: Git Status
+Checking current git status...
+
+!git status
+
+---
+
+## Summary
+
+All checks completed! Here's what was verified:
+- ✅ **Linting**: Code follows style guidelines
+- ✅ **Formatting**: Code is properly formatted
+- ✅ **Type Checking**: No type errors
+- ✅ **Build**: Package builds successfully
+
+If all checks passed, your code is ready for PR!
+
+If you provided a commit message argument, I can help you create the commit. Otherwise, you can now:
+
+1. Stage your changes: `git add .`
+2. Create a commit with a proper message format: `git commit -m "feat: your-description"`
+3. Push your branch: `git push origin your-branch-name`
+4. Create a PR with a descriptive title and summary
+
+**Remember**: PR titles should be concise and follow the format: `feat/fix/docs: description`

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.87"
+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.87 → uipath-2.1.89}/src/uipath/_cli/__init__.py

@@ -3,7 +3,7 @@ import sys
 
 import click
 
-from ._utils._common import load_environment_variables
+from ._utils._common import add_cwd_to_path, load_environment_variables
 from .cli_auth import auth as auth
 from .cli_deploy import deploy as deploy  # type: ignore
 from .cli_dev import dev as dev
@@ -45,6 +45,7 @@ def _get_safe_version() -> str:
 )
 def cli(lv: bool, v: bool) -> None:
     load_environment_variables()
+    add_cwd_to_path()
     if lv:
         try:
             version = importlib.metadata.version("uipath-langchain")

{uipath-2.1.87 → 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.87 → 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.87 → 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.87 → 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.87 → 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.87 → uipath-2.1.89}/src/uipath/_cli/_utils/_common.py

@@ -9,6 +9,14 @@ from ..._utils.constants import DOTENV_FILE
 from ..spinner import Spinner
 
 
+def add_cwd_to_path():
+    import sys
+
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+
 def environment_options(function):
     function = click.option(
         "--alpha",