uipath 2.1.89__tar.gz → 2.1.90__tar.gz

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

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

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

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

{uipath-2.1.89 → uipath-2.1.90}/src/uipath/_resources/AGENTS.md

@@ -1,6 +1,6 @@
 # Agent Code Patterns Reference
 
-This document provides practical code patterns for building UiPath coded agents using LangGraph and the UiPath Python SDK.
+This document provides practical code patterns for building UiPath coded agents using the UiPath Python SDK.
 
 ---
 
@@ -8,32 +8,14 @@ This document provides practical code patterns for building UiPath coded agents
 
 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
+   - **Contains:** Required Pydantic models (Input, Output), SDK initialization patterns, standard agent template
 
 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

uipath-2.1.90/src/uipath/_resources/REQUIRED_STRUCTURE.md

@@ -0,0 +1,64 @@
+## Required Agent Structure
+
+**IMPORTANT**: All UiPath coded agents MUST follow this standard structure unless explicitly specified otherwise by the user.
+
+### Required Components
+
+Every agent implementation MUST include these two Pydantic models:
+
+```python
+from pydantic import BaseModel
+
+class Input(BaseModel):
+    """Define input fields that the agent accepts"""
+    # Add your input fields here
+    pass
+
+class Output(BaseModel):
+    """Define output fields that the agent returns"""
+    # Add your output fields here
+    pass
+```
+
+### SDK Initialization
+
+```python
+from uipath import UiPath
+
+# Initialize with environment variables
+uipath = UiPath()
+
+# With explicit credentials
+uipath = UiPath(base_url="https://cloud.uipath.com/...", secret="your_token")
+
+# Or with client_id and client_secret
+uipath = UiPath(
+    client_id=UIPATH_CLIENT_ID,
+    client_secret=UIPATH_CLIENT_SECRET,
+    scope=UIPATH_SCOPE,
+    base_url=UIPATH_URL
+)
+```
+
+### Standard Agent Template
+
+Every agent should follow this basic structure:
+
+```python
+from uipath import UiPath
+from pydantic import BaseModel
+
+# 1. Define Input, and Output models
+class Input(BaseModel):
+    field: str
+
+class Output(BaseModel):
+    result: str
+
+# 2. Initialize with environment variables
+uipath = UiPath()
+
+# 3. Define the main function (the main function can be named "main", "run" or "execute")
+def main(input_data: Input) -> Output:
+     pass
+```

{uipath-2.1.89 → uipath-2.1.90}/src/uipath/_resources/SDK_REFERENCE.md

@@ -1,4 +1,4 @@
-## Quick API Reference
+## API Reference
 
 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.
 

uipath-2.1.90/tests/cli/test_init_agents_md.py

@@ -0,0 +1,210 @@
+"""Tests for AGENTS.md generation in the init command."""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath._cli.cli_init import (  # type: ignore[attr-defined]
+    generate_agent_md_file,
+    generate_agent_md_files,
+)
+
+
+class TestGenerateAgentMdFile:
+    """Test the generate_agent_md_file helper function."""
+
+    def test_generate_agent_md_file_creates_file(self) -> None:
+        """Test that a single md file is created successfully."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                mock_source = (
+                    Path(__file__).parent.parent.parent
+                    / "src"
+                    / "uipath"
+                    / "_resources"
+                    / "AGENTS.md"
+                )
+
+                with (
+                    patch(
+                        "uipath._cli.cli_init.importlib.resources.files"
+                    ) as mock_files,
+                    patch(
+                        "uipath._cli.cli_init.importlib.resources.as_file"
+                    ) as mock_as_file,
+                ):
+                    mock_path = MagicMock()
+                    mock_files.return_value.joinpath.return_value = mock_path
+                    mock_as_file.return_value.__enter__.return_value = mock_source
+                    mock_as_file.return_value.__exit__.return_value = None
+
+                    generate_agent_md_file(temp_dir, "AGENTS.md")
+
+                    assert (Path(temp_dir) / "AGENTS.md").exists()
+            finally:
+                os.chdir(original_cwd)
+
+    def test_generate_agents_md_skips_existing_file(self) -> None:
+        """Test that existing AGENTS.md is not overwritten."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            agents_path = Path(temp_dir) / "AGENTS.md"
+            original_content = "Original content"
+            agents_path.write_text(original_content)
+
+            generate_agent_md_file(temp_dir, "AGENTS.md")
+
+            assert agents_path.read_text() == original_content
+
+    def test_generate_agents_md_handles_errors_gracefully(self) -> None:
+        """Test that errors are handled gracefully."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch("uipath._cli.cli_init.console") as mock_console,
+            ):
+                mock_files.side_effect = RuntimeError("Test error")
+
+                generate_agent_md_file(temp_dir, "AGENTS.md")
+
+                mock_console.warning.assert_called_once()
+                assert "Could not create AGENTS.md: Test error" in str(
+                    mock_console.warning.call_args
+                )
+
+
+class TestGenerateAgentMdFiles:
+    """Test the generate_agent_md_files function that creates multiple files."""
+
+    def test_generate_agent_md_files_creates_all_files(self) -> None:
+        """Test that all root and agent files are created in the correct locations."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+                patch("uipath._cli.cli_init.console"),
+            ):
+                temp_source = Path(temp_dir) / "temp_source.md"
+                temp_source.write_text("Test content")
+
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                generate_agent_md_files(temp_dir)
+
+                agent_dir = Path(temp_dir) / ".agent"
+                assert agent_dir.exists()
+                assert agent_dir.is_dir()
+
+                assert (Path(temp_dir) / "AGENTS.md").exists()
+                assert (Path(temp_dir) / "CLAUDE.md").exists()
+
+                assert (agent_dir / "CLI_REFERENCE.md").exists()
+                assert (agent_dir / "REQUIRED_STRUCTURE.md").exists()
+                assert (agent_dir / "SDK_REFERENCE.md").exists()
+
+    def test_generate_agent_md_files_skips_existing_files(self) -> None:
+        """Test that existing files are not overwritten."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            agent_dir = Path(temp_dir) / ".agent"
+            agent_dir.mkdir()
+
+            agents_path = Path(temp_dir) / "AGENTS.md"
+            agents_content = "Original AGENTS content"
+            agents_path.write_text(agents_content)
+
+            cli_ref_path = agent_dir / "CLI_REFERENCE.md"
+            cli_ref_content = "Original CLI_REFERENCE content"
+            cli_ref_path.write_text(cli_ref_content)
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+            ):
+                temp_source = Path(temp_dir) / "temp_source.md"
+                temp_source.write_text("Test content")
+
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                generate_agent_md_files(temp_dir)
+
+                assert agents_path.read_text() == agents_content
+                assert cli_ref_path.read_text() == cli_ref_content
+
+
+class TestInitWithAgentsMd:
+    """Test the init command with default AGENTS.md creation."""
+
+    def test_init_creates_agent_files_by_default(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that agent files are created by default during init."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a simple Python file
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            temp_source = Path(temp_dir) / "temp_source.md"
+            temp_source.write_text("Test content")
+
+            with (
+                patch("uipath._cli.cli_init.importlib.resources.files") as mock_files,
+                patch(
+                    "uipath._cli.cli_init.importlib.resources.as_file"
+                ) as mock_as_file,
+            ):
+                # Setup mocks
+                mock_path = MagicMock()
+                mock_files.return_value.joinpath.return_value = mock_path
+                mock_as_file.return_value.__enter__.return_value = temp_source
+                mock_as_file.return_value.__exit__.return_value = None
+
+                result = runner.invoke(cli, ["init"])
+
+                assert result.exit_code == 0
+                assert "AGENTS.md" in result.output
+                assert "file." in result.output
+
+                assert os.path.exists("AGENTS.md")
+                assert os.path.exists("CLAUDE.md")
+
+                assert os.path.exists(".agent/CLI_REFERENCE.md")
+                assert os.path.exists(".agent/REQUIRED_STRUCTURE.md")
+                assert os.path.exists(".agent/SDK_REFERENCE.md")
+
+    def test_init_does_not_overwrite_existing_agents_md(
+        self, runner: CliRunner, temp_dir: str
+    ) -> None:
+        """Test that existing AGENTS.md is not overwritten."""
+        with runner.isolated_filesystem(temp_dir=temp_dir):
+            # Create a simple Python file
+            with open("main.py", "w") as f:
+                f.write("def main(input): return input")
+
+            # Create existing AGENTS.md
+            original_content = "Original AGENTS.md content"
+            with open("AGENTS.md", "w") as f:
+                f.write(original_content)
+
+            # Run init (AGENTS.md creation is now default)
+            result = runner.invoke(cli, ["init"])
+
+            assert result.exit_code == 0
+
+            # Verify content wasn't changed
+            with open("AGENTS.md", "r") as f:
+                assert f.read() == original_content

{uipath-2.1.89 → uipath-2.1.90}/uv.lock

@@ -2146,7 +2146,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.89"
+version = "2.1.90"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },