uipath 2.1.117__tar.gz → 2.1.118__tar.gz

{uipath-2.1.117 → uipath-2.1.118}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.117"
+version = "2.1.118"
 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.117 → uipath-2.1.118}/src/uipath/_cli/_auth/_auth_service.py

@@ -121,7 +121,7 @@ class AuthService:
         return False
 
     def _perform_oauth_flow(self) -> TokenData:
-        auth_config = OidcUtils.get_auth_config()
+        auth_config = OidcUtils.get_auth_config(self._domain)
         auth_url, code_verifier, state = OidcUtils.get_auth_url(
             self._domain, auth_config
         )

uipath-2.1.118/src/uipath/_cli/_auth/_oidc_utils.py

@@ -0,0 +1,196 @@
+import base64
+import hashlib
+import json
+import os
+from typing import Optional
+from urllib.parse import urlencode, urlparse
+
+import httpx
+
+from ..._utils._ssl_context import get_httpx_client_kwargs
+from .._utils._console import ConsoleLogger
+from ._models import AuthConfig
+from ._url_utils import build_service_url
+
+
+def generate_code_verifier_and_challenge():
+    """Generate PKCE code verifier and challenge."""
+    code_verifier = base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+    code_challenge_bytes = hashlib.sha256(code_verifier.encode("utf-8")).digest()
+    code_challenge = (
+        base64.urlsafe_b64encode(code_challenge_bytes).decode("utf-8").rstrip("=")
+    )
+
+    return code_verifier, code_challenge
+
+
+def get_state_param() -> str:
+    return base64.urlsafe_b64encode(os.urandom(32)).decode("utf-8").rstrip("=")
+
+
+def _get_version_from_api(domain: str) -> Optional[str]:
+    """Fetch the version from the UiPath orchestrator API.
+
+    Args:
+        domain: The UiPath domain (e.g., 'https://alpha.uipath.com')
+
+    Returns:
+        The version string (e.g., '25.10.0-beta.415') or None if unable to fetch
+    """
+    try:
+        version_url = build_service_url(domain, "/orchestrator_/api/status/version")
+        client_kwargs = get_httpx_client_kwargs()
+        # Override timeout for version check
+        client_kwargs["timeout"] = 5.0
+
+        with httpx.Client(**client_kwargs) as client:
+            response = client.get(version_url)
+            response.raise_for_status()
+            data = response.json()
+            return data.get("version")
+    except Exception:
+        # Silently fail and return None if we can't fetch the version
+        return None
+
+
+def _is_cloud_domain(domain: str) -> bool:
+    """Check if the domain is a cloud domain (alpha, staging, or cloud.uipath.com).
+
+    Args:
+        domain: The domain string (e.g., 'https://alpha.uipath.com')
+
+    Returns:
+        True if it's a cloud domain, False otherwise
+    """
+    parsed = urlparse(domain)
+    netloc = parsed.netloc.lower()
+    return netloc in [
+        "alpha.uipath.com",
+        "staging.uipath.com",
+        "cloud.uipath.com",
+    ]
+
+
+def _select_config_file(domain: str) -> str:
+    """Select the appropriate auth config file based on domain and version.
+
+    Logic:
+    1. If domain is alpha/staging/cloud.uipath.com -> use auth_config_cloud.json
+    2. Otherwise, try to get version from API
+    3. If version starts with '25.10' -> use auth_config_25_10.json
+    4. If version can't be determined -> fallback to auth_config_cloud.json
+    5. Otherwise -> fallback to auth_config_cloud.json
+
+    Args:
+        domain: The UiPath domain
+
+    Returns:
+        The filename of the config to use
+    """
+    # Check if it's a known cloud domain
+    if _is_cloud_domain(domain):
+        return "auth_config_cloud.json"
+
+    # Try to get version from API
+    version = _get_version_from_api(domain)
+
+    # If we can't determine version, fallback to cloud config
+    if version is None:
+        return "auth_config_cloud.json"
+
+    # Check if version is 25.10.*
+    if version.startswith("25.10"):
+        return "auth_config_25_10.json"
+
+    # Default fallback to cloud config
+    return "auth_config_cloud.json"
+
+
+class OidcUtils:
+    _console = ConsoleLogger()
+
+    @classmethod
+    def _find_free_port(cls, candidates: list[int]):
+        from socket import AF_INET, SOCK_STREAM, error, socket
+
+        def is_free(port: int) -> bool:
+            with socket(AF_INET, SOCK_STREAM) as s:
+                try:
+                    s.bind(("localhost", port))
+                    return True
+                except error:
+                    return False
+
+        return next((p for p in candidates if is_free(p)), None)
+
+    @classmethod
+    def get_auth_config(cls, domain: Optional[str] = None) -> AuthConfig:
+        """Get the appropriate auth configuration based on domain.
+
+        Args:
+            domain: The UiPath domain (e.g., 'https://cloud.uipath.com').
+                   If None, uses default auth_config_cloud.json
+
+        Returns:
+            AuthConfig with the appropriate configuration
+        """
+        # Select the appropriate config file based on domain
+        if domain:
+            config_file = _select_config_file(domain)
+        else:
+            config_file = "auth_config_cloud.json"
+
+        config_path = os.path.join(os.path.dirname(__file__), config_file)
+        with open(config_path, "r") as f:
+            auth_config = json.load(f)
+
+        custom_port = os.getenv("UIPATH_AUTH_PORT")
+        candidates = [int(custom_port)] if custom_port else [8104, 8055, 42042]
+
+        port = cls._find_free_port(candidates)
+        if port is None:
+            ports_str = ", ".join(str(p) for p in candidates)
+            cls._console.error(
+                f"All configured ports ({ports_str}) are in use. Please close applications using these ports or configure different ports."
+            )
+
+        redirect_uri = auth_config["redirect_uri"].replace(
+            "__PY_REPLACE_PORT__", str(port)
+        )
+
+        return AuthConfig(
+            client_id=auth_config["client_id"],
+            redirect_uri=redirect_uri,
+            scope=auth_config["scope"],
+            port=port,
+        )
+
+    @classmethod
+    def get_auth_url(cls, domain: str, auth_config: AuthConfig) -> tuple[str, str, str]:
+        """Get the authorization URL for OAuth2 PKCE flow.
+
+        Args:
+            domain (str): The UiPath domain to authenticate against (e.g. 'alpha', 'cloud')
+            auth_config (AuthConfig): The authentication configuration to use
+
+        Returns:
+            tuple[str, str]: A tuple containing:
+                - The authorization URL with query parameters
+                - The code verifier for PKCE flow
+        """
+        code_verifier, code_challenge = generate_code_verifier_and_challenge()
+        state = get_state_param()
+        query_params = {
+            "client_id": auth_config["client_id"],
+            "redirect_uri": auth_config["redirect_uri"],
+            "response_type": "code",
+            "scope": auth_config["scope"],
+            "state": state,
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+        }
+
+        query_string = urlencode(query_params)
+        url = build_service_url(domain, f"/identity_/connect/authorize?{query_string}")
+        return url, code_verifier, state

{uipath-2.1.117 → uipath-2.1.118}/src/uipath/_cli/_auth/_portal_service.py

@@ -94,7 +94,7 @@ class PortalService:
 
     def refresh_access_token(self, refresh_token: str) -> TokenData:  # type: ignore
         url = build_service_url(self.domain, "/identity_/connect/token")
-        client_id = OidcUtils.get_auth_config().get("client_id")
+        client_id = OidcUtils.get_auth_config(self.domain).get("client_id")
 
         data = {
             "grant_type": "refresh_token",

{uipath-2.1.117 → uipath-2.1.118}/src/uipath/_cli/_auth/_url_utils.py

@@ -15,13 +15,20 @@ def resolve_domain(
     Args:
         base_url: The base URL explicitly provided.
         environment: The environment name (e.g., 'alpha', 'staging', 'cloud').
-        force: Whether to ignore UIPATH_URL from environment variables.
+        force: Whether to ignore UIPATH_URL from environment variables when base_url is set.
 
     Returns:
         A valid base URL for UiPath services.
     """
-    if not force:
-        # If UIPATH_URL is set, prefer its domain
+    # If base_url is a real URL, prefer it
+    if base_url and base_url.startswith("http"):
+        parsed = urlparse(base_url)
+        domain = f"{parsed.scheme}://{parsed.netloc}"
+        if domain:
+            return domain
+
+    # If base_url is not set (or force is False), check UIPATH_URL
+    if not base_url or not force:
         uipath_url = os.getenv("UIPATH_URL")
         if uipath_url and environment == "cloud":
             parsed = urlparse(uipath_url)
@@ -34,13 +41,6 @@ def resolve_domain(
                     "Please ensure it includes scheme and netloc (e.g., 'https://cloud.uipath.com')."
                 )
 
-    # If base_url is a real URL, prefer it
-    if base_url and base_url.startswith("http"):
-        parsed = urlparse(base_url)
-        domain = f"{parsed.scheme}://{parsed.netloc}"
-        if domain:
-            return domain
-
     # Otherwise, fall back to environment
     return f"https://{environment or 'cloud'}.uipath.com"
 

uipath-2.1.118/src/uipath/_cli/_auth/auth_config_cloud.json

@@ -0,0 +1,6 @@
+{
+  "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
+  "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
+  "scope": "offline_access ProcessMining OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DocumentUnderstanding Du.Digitization.Api Du.Classification.Api Du.Extraction.Api Du.Validation.Api EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "port": 8104
+}

{uipath-2.1.117 → uipath-2.1.118}/src/uipath/_resources/CLI_REFERENCE.md

@@ -62,10 +62,10 @@ uv run uipath init --infer-bindings
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `--resume` | flag | false | Resume execution from a previous state |
-| `-f`, `--file` | value | none | File path for the .json input |
-| `--input-file` | value | none | Alias for '-f/--file' arguments |
-| `--output-file` | value | none | File path where the output will be written |
-| `--trace-file` | value | none | File path where the trace spans will be written (JSON Lines format) |
+| `-f`, `--file` | value | `Sentinel.UNSET` | File path for the .json input |
+| `--input-file` | value | `Sentinel.UNSET` | Alias for '-f/--file' arguments |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
+| `--trace-file` | value | `Sentinel.UNSET` | File path where the trace spans will be written (JSON Lines format) |
 | `--debug` | flag | false | Enable debugging with debugpy. The process will wait for a debugger to attach. |
 | `--debug-port` | value | `5678` | Port for the debug server (default: 5678) |
 
@@ -117,7 +117,7 @@ uv run uipath run --resume
 |--------|------|---------|-------------|
 | `--no-report` | flag | false | Do not report the evaluation results |
 | `--workers` | value | `1` | Number of parallel workers for running evaluations (default: 1) |
-| `--output-file` | value | none | File path where the output will be written |
+| `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |
 
 **Usage Examples:**
 

{uipath-2.1.117 → uipath-2.1.118}/src/uipath/agent/models/agent.py

@@ -278,13 +278,25 @@ class AgentContextOutputColumn(BaseModel):
     )
 
 
+class AgentContextRetrievalMode(str, Enum):
+    """Enum for retrieval modes."""
+
+    SEMANTIC = "Semantic"
+    STRUCTURED = "Structured"
+    DEEP_RAG = "DeepRAG"
+    BATCH_TRANSFORM = "BatchTransform"
+
+
 class AgentContextSettings(BaseModel):
     """Settings for context."""
 
     result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured", "DeepRAG", "BatchTransform"] = (
-        Field(alias="retrievalMode")
-    )
+    retrieval_mode: Literal[
+        AgentContextRetrievalMode.SEMANTIC,
+        AgentContextRetrievalMode.STRUCTURED,
+        AgentContextRetrievalMode.DEEP_RAG,
+        AgentContextRetrievalMode.BATCH_TRANSFORM,
+    ] = Field(alias="retrievalMode")
     threshold: float = Field(default=0)
     query: Optional[AgentContextQuerySetting] = Field(None)
     folder_path_prefix: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = (
@@ -303,6 +315,20 @@ class AgentContextSettings(BaseModel):
         None, alias="outputColumns"
     )
 
+    @field_validator("retrieval_mode", mode="before")
+    @classmethod
+    def normalize_retrieval_mode(cls, v: Any) -> str:
+        """Normalize context retrieval mode."""
+        if isinstance(v, str):
+            lowercase_mapping = {
+                "semantic": AgentContextRetrievalMode.SEMANTIC,
+                "structured": AgentContextRetrievalMode.STRUCTURED,
+                "deeprag": AgentContextRetrievalMode.DEEP_RAG,
+                "batchtransform": AgentContextRetrievalMode.BATCH_TRANSFORM,
+            }
+            return lowercase_mapping.get(v.lower(), v)
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
@@ -553,7 +579,7 @@ class AgentGuardrailLogAction(BaseModel):
     """Log action model."""
 
     action_type: Literal["log"] = Field(alias="$actionType")
-    message: str = Field(..., alias="message")
+    message: Optional[str] = Field(None, alias="message")
     severity_level: AgentGuardrailSeverityLevel = Field(alias="severityLevel")
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")

uipath-2.1.118/tests/cli/test_oidc_utils.py

@@ -0,0 +1,233 @@
+"""
+Unit tests for OidcUtils.get_auth_config() method.
+
+IMPORTANT: Backwards Compatibility Notice
+=========================================
+If any values in auth_config.json are changed, we MUST maintain backwards
+compatibility with release/2025.10 branches or later.
+"""
+
+import json
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from uipath._cli._auth._oidc_utils import (
+    OidcUtils,
+    _get_version_from_api,
+    _is_cloud_domain,
+    _select_config_file,
+)
+
+
+class TestOidcUtils:
+    """Test suite for OidcUtils class."""
+
+    def test_auth_config_backwards_compatibility_v2025_10(self):
+        """
+        Test that auth_config_25_10.json maintains backwards compatibility with release/v2025.10.
+
+        This test validates that the authentication configuration values remain
+        unchanged to ensure compatibility with release/v2025.10 and later branches.
+
+        CRITICAL: Any failure indicates a breaking change that requires coordination
+        across all supported release branches.
+        """
+        # Read the actual auth_config_25_10.json file
+        config_path = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "src",
+            "uipath",
+            "_cli",
+            "_auth",
+            "auth_config_25_10.json",
+        )
+
+        with open(config_path, "r") as f:
+            actual_config = json.load(f)
+
+        # Assert exact values for non-scope fields
+        assert actual_config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00", (
+            f"BACKWARDS COMPATIBILITY VIOLATION: client_id has changed! "
+            f"Expected: 36dea5b8-e8bb-423d-8e7b-c808df8f1c00, Got: {actual_config['client_id']}"
+        )
+
+        assert (
+            actual_config["redirect_uri"]
+            == "http://localhost:__PY_REPLACE_PORT__/oidc/login"
+        ), (
+            f"BACKWARDS COMPATIBILITY VIOLATION: redirect_uri has changed! "
+            f"Expected: http://localhost:__PY_REPLACE_PORT__/oidc/login, Got: {actual_config['redirect_uri']}"
+        )
+
+        assert actual_config["port"] == 8104, (
+            f"BACKWARDS COMPATIBILITY VIOLATION: port has changed! "
+            f"Expected: 8104, Got: {actual_config['port']}"
+        )
+
+        # For scopes, ensure actual scopes are a subset of the allowed scopes (no new scopes allowed)
+        allowed_scopes = set(
+            [
+                "offline_access",
+                "ProcessMining",
+                "OrchestratorApiUserAccess",
+                "StudioWebBackend",
+                "IdentityServerApi",
+                "ConnectionService",
+                "DataService",
+                "DocumentUnderstanding",
+                "Du.Digitization.Api",
+                "Du.Classification.Api",
+                "Du.Extraction.Api",
+                "Du.Validation.Api",
+                "EnterpriseContextService",
+                "Directory",
+                "JamJamApi",
+                "LLMGateway",
+                "LLMOps",
+                "OMS",
+                "RCS.FolderAuthorization",
+                "TM.Projects",
+                "TM.TestCases",
+                "TM.Requirements",
+                "TM.TestSets",
+            ]
+        )
+
+        actual_scopes = set(actual_config["scope"].split())
+
+        assert actual_scopes.issubset(allowed_scopes), (
+            f"BACKWARDS COMPATIBILITY VIOLATION: New scopes detected that are not allowed on v2025.10! "
+            f"New scopes: {actual_scopes - allowed_scopes}. "
+            f"Only subsets of the following scopes are permitted: {sorted(allowed_scopes)}"
+        )
+
+    @pytest.mark.parametrize(
+        "domain,expected",
+        [
+            ("https://alpha.uipath.com", True),
+            ("https://staging.uipath.com", True),
+            ("https://cloud.uipath.com", True),
+            ("https://ALPHA.UIPATH.COM", True),  # Test case insensitivity
+            ("https://custom.domain.com", False),
+            ("https://cloud.uipath.dev", False),
+            ("https://alpha-test.uipath.com", False),
+        ],
+    )
+    def test_is_cloud_domain(self, domain, expected):
+        """Test _is_cloud_domain correctly identifies cloud domains."""
+        assert _is_cloud_domain(domain) == expected
+
+    def test_get_version_from_api_success(self):
+        """Test _get_version_from_api successfully fetches version."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "version": "25.10.0-beta.415",
+            "timestamp": "2025-10-23T19:08:22Z",
+            "deployment": "ServiceFabric",
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = MagicMock()
+        mock_client.get.return_value = mock_response
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__ = MagicMock()
+
+        with patch("httpx.Client", return_value=mock_client):
+            version = _get_version_from_api("https://custom.domain.com")
+            assert version == "25.10.0-beta.415"
+
+    def test_get_version_from_api_timeout(self):
+        """Test _get_version_from_api handles timeouts gracefully."""
+        mock_client = MagicMock()
+        mock_client.get.side_effect = TimeoutError
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__ = MagicMock()
+
+        with patch("httpx.Client", return_value=mock_client):
+            version = _get_version_from_api("https://custom.domain.com")
+            assert version is None
+
+    def test_get_version_from_api_network_error(self):
+        """Test _get_version_from_api handles network errors gracefully."""
+        mock_client = MagicMock()
+        mock_client.get.side_effect = Exception("Network error")
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__ = MagicMock()
+
+        with patch("httpx.Client", return_value=mock_client):
+            version = _get_version_from_api("https://custom.domain.com")
+            assert version is None
+
+    @pytest.mark.parametrize(
+        "domain,mock_version,expected_config",
+        [
+            # Cloud domains should always use auth_config_cloud.json
+            ("https://alpha.uipath.com", None, "auth_config_cloud.json"),
+            ("https://staging.uipath.com", None, "auth_config_cloud.json"),
+            ("https://cloud.uipath.com", None, "auth_config_cloud.json"),
+            # Version 25.10.* should use auth_config_25_10.json
+            (
+                "https://custom.domain.com",
+                "25.10.0-beta.415",
+                "auth_config_25_10.json",
+            ),
+            ("https://custom.domain.com", "25.10.1", "auth_config_25_10.json"),
+            # Other versions should fallback to cloud config
+            ("https://custom.domain.com", "24.10.0", "auth_config_cloud.json"),
+            ("https://custom.domain.com", "26.1.0", "auth_config_cloud.json"),
+            # Unable to determine version should fallback to cloud config
+            ("https://custom.domain.com", None, "auth_config_cloud.json"),
+        ],
+    )
+    def test_select_config_file(self, domain, mock_version, expected_config):
+        """Test _select_config_file selects the correct config based on domain and version."""
+        with patch(
+            "uipath._cli._auth._oidc_utils._get_version_from_api",
+            return_value=mock_version,
+        ):
+            config_file = _select_config_file(domain)
+            assert config_file == expected_config
+
+    def test_get_auth_config_without_domain(self):
+        """Test get_auth_config without domain parameter uses default config."""
+        with patch(
+            "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port", return_value=8104
+        ):
+            config = OidcUtils.get_auth_config()
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104
+
+    def test_get_auth_config_with_cloud_domain(self):
+        """Test get_auth_config with cloud domain uses auth_config_cloud.json."""
+        with patch(
+            "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port", return_value=8104
+        ):
+            config = OidcUtils.get_auth_config("https://alpha.uipath.com")
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104
+
+    def test_get_auth_config_with_25_10_version(self):
+        """Test get_auth_config with version 25.10 uses auth_config_25_10.json."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"version": "25.10.0-beta.415"}
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = MagicMock()
+        mock_client.get.return_value = mock_response
+        mock_client.__enter__.return_value = mock_client
+        mock_client.__exit__ = MagicMock()
+
+        with (
+            patch("httpx.Client", return_value=mock_client),
+            patch(
+                "uipath._cli._auth._oidc_utils.OidcUtils._find_free_port",
+                return_value=8104,
+            ),
+        ):
+            config = OidcUtils.get_auth_config("https://custom.domain.com")
+            assert config["client_id"] == "36dea5b8-e8bb-423d-8e7b-c808df8f1c00"
+            assert config["port"] == 8104