uipath 2.1.80__py3-none-any.whl → 2.1.81__py3-none-any.whl

uipath/_cli/_auth/_auth_service.py

@@ -1,22 +1,19 @@
 import asyncio
-import json
 import os
 import webbrowser
-from socket import AF_INET, SOCK_STREAM, error, socket
 from typing import Optional
-from urllib.parse import urlparse
 
 from uipath._cli._auth._auth_server import HTTPServer
-from uipath._cli._auth._client_credentials import ClientCredentialsService
 from uipath._cli._auth._oidc_utils import OidcUtils
 from uipath._cli._auth._portal_service import (
     PortalService,
-    get_tenant_id,
-    select_tenant,
 )
-from uipath._cli._auth._url_utils import set_force_flag
-from uipath._cli._auth._utils import update_auth_file, update_env_file
+from uipath._cli._auth._url_utils import extract_org_tenant, resolve_domain
+from uipath._cli._auth._utils import get_parsed_token_data
 from uipath._cli._utils._console import ConsoleLogger
+from uipath._services import ExternalApplicationService
+from uipath._utils._auth import update_env_file
+from uipath.models.auth import TokenData
 
 
 class AuthService:
@@ -25,35 +22,20 @@ class AuthService:
         environment: str,
         *,
         force: bool,
-        client_id: Optional[str],
-        client_secret: Optional[str],
-        base_url: Optional[str],
-        tenant: Optional[str],
-        scope: Optional[str],
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        base_url: Optional[str] = None,
+        tenant: Optional[str] = None,
+        scope: Optional[str] = None,
     ):
         self._force = force
         self._console = ConsoleLogger()
-        self._domain = self._get_domain(environment)
         self._client_id = client_id
         self._client_secret = client_secret
         self._base_url = base_url
         self._tenant = tenant
+        self._domain = resolve_domain(self._base_url, environment, self._force)
         self._scope = scope
-        set_force_flag(self._force)
-
-    def _get_domain(self, environment: str) -> str:
-        # only search env var if not force authentication
-        if not self._force:
-            uipath_url = os.getenv("UIPATH_URL")
-            if uipath_url and environment == "cloud":  # "cloud" is the default
-                parsed_url = urlparse(uipath_url)
-                if parsed_url.scheme and parsed_url.netloc:
-                    environment = f"{parsed_url.scheme}://{parsed_url.netloc}"
-                else:
-                    self._console.error(
-                        f"Malformed UIPATH_URL: '{uipath_url}'. Please ensure it includes both scheme and netloc (e.g., 'https://cloud.uipath.com')."
-                    )
-        return environment
 
     def authenticate(self) -> None:
         if self._client_id and self._client_secret:
@@ -62,103 +44,101 @@ class AuthService:
 
         self._authenticate_authorization_code()
 
-    def _authenticate_client_credentials(self) -> None:
-        if not self._base_url:
-            self._console.error(
-                "--base-url is required when using client credentials authentication."
-            )
-            return
-        self._console.hint("Using client credentials authentication.")
-        credentials_service = ClientCredentialsService(self._base_url)
-        credentials_service.authenticate(
+    def _authenticate_client_credentials(self):
+        external_app_service = ExternalApplicationService(self._base_url)
+        token_data = external_app_service.get_token_data(
             self._client_id,  # type: ignore
             self._client_secret,  # type: ignore
             self._scope,
         )
 
-    def _authenticate_authorization_code(self) -> None:
-        with PortalService(self._domain) as portal_service:
-            if not self._force:
-                # use existing env vars
-                if (
-                    os.getenv("UIPATH_URL")
-                    and os.getenv("UIPATH_TENANT_ID")
-                    and os.getenv("UIPATH_ORGANIZATION_ID")
-                ):
-                    try:
-                        portal_service.ensure_valid_token()
-                        return
-                    except Exception:
-                        self._console.error(
-                            "Authentication token is invalid. Please reauthenticate using the '--force' flag.",
-                        )
-            auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
-            webbrowser.open(auth_url, 1)
-            auth_config = OidcUtils.get_auth_config()
-
-            self._console.link(
-                "If a browser window did not open, please open the following URL in your browser:",
-                auth_url,
+        organization_name, tenant_name = extract_org_tenant(
+            external_app_service._base_url
+        )
+        if not (organization_name and tenant_name):
+            self._console.warning(
+                "--base-url should include both organization and tenant, "
+                "e.g., 'https://cloud.uipath.com/{organization}/{tenant}'."
             )
-            server = HTTPServer(port=auth_config["port"])
-            token_data = asyncio.run(server.start(state, code_verifier, self._domain))
 
-            if not token_data:
-                self._console.error(
-                    "Authentication failed. Please try again.",
-                )
+        env_vars = {
+            "UIPATH_ACCESS_TOKEN": token_data.access_token,
+            "UIPATH_URL": external_app_service._base_url,
+            "UIPATH_ORGANIZATION_ID": get_parsed_token_data(token_data).get("prt_id"),
+        }
+
+        if tenant_name:
+            self._tenant = tenant_name
+            with PortalService(
+                self._domain, access_token=token_data.access_token
+            ) as portal_service:
+                tenant_info = portal_service.resolve_tenant_info(self._tenant)
+                env_vars["UIPATH_TENANT_ID"] = tenant_info["tenant_id"]
+        else:
+            self._console.warning("Could not extract tenant from --base-url.")
+        update_env_file(env_vars)
+
+    def _authenticate_authorization_code(self) -> None:
+        with PortalService(self._domain) as portal_service:
+            if not self._force and self._can_reuse_existing_token(portal_service):
+                return
 
+            token_data = self._perform_oauth_flow()
             portal_service.update_token_data(token_data)
-            update_auth_file(token_data)
-            access_token = token_data["access_token"]
-            update_env_file({"UIPATH_ACCESS_TOKEN": access_token})
 
-            tenants_and_organizations = portal_service.get_tenants_and_organizations()
+            tenant_info = portal_service.resolve_tenant_info(self._tenant)
+            uipath_url = portal_service.build_tenant_url()
 
-            if self._tenant:
-                base_url = get_tenant_id(
-                    self._domain, self._tenant, tenants_and_organizations
+            update_env_file(
+                {
+                    "UIPATH_ACCESS_TOKEN": token_data.access_token,
+                    "UIPATH_URL": uipath_url,
+                    "UIPATH_TENANT_ID": tenant_info["tenant_id"],
+                    "UIPATH_ORGANIZATION_ID": tenant_info["organization_id"],
+                }
+            )
+
+            try:
+                portal_service.enable_studio_web(uipath_url)
+            except Exception:
+                self._console.error(
+                    "Could not prepare the environment. Please try again."
                 )
-            else:
-                base_url = select_tenant(self._domain, tenants_and_organizations)
 
+    def _can_reuse_existing_token(self, portal_service: PortalService) -> bool:
+        if (
+            os.getenv("UIPATH_URL")
+            and os.getenv("UIPATH_TENANT_ID")
+            and os.getenv("UIPATH_ORGANIZATION_ID")
+        ):
             try:
-                portal_service.post_auth(base_url)
+                portal_service.ensure_valid_token()
+                return True
             except Exception:
                 self._console.error(
-                    "Could not prepare the environment. Please try again.",
+                    "Authentication token is invalid. Please reauthenticate using the '--force' flag."
                 )
+        return False
 
-    def set_port(self):
-        def is_port_in_use(target_port: int) -> bool:
-            with socket(AF_INET, SOCK_STREAM) as s:
-                try:
-                    s.bind(("localhost", target_port))
-                    s.close()
-                    return False
-                except error:
-                    return True
+    def _perform_oauth_flow(self) -> TokenData:
+        auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
+        self._open_browser(auth_url)
 
         auth_config = OidcUtils.get_auth_config()
-        port = int(auth_config.get("port", 8104))
-        port_option_one = int(auth_config.get("portOptionOne", 8104))  # type: ignore
-        port_option_two = int(auth_config.get("portOptionTwo", 8055))  # type: ignore
-        port_option_three = int(auth_config.get("portOptionThree", 42042))  # type: ignore
-        if is_port_in_use(port):
-            if is_port_in_use(port_option_one):
-                if is_port_in_use(port_option_two):
-                    if is_port_in_use(port_option_three):
-                        self._console.error(
-                            "All configured ports are in use. Please close applications using ports or configure different ports."
-                        )
-                    else:
-                        port = port_option_three
-                else:
-                    port = port_option_two
-            else:
-                port = port_option_one
-        auth_config["port"] = port
-        with open(
-            os.path.join(os.path.dirname(__file__), "..", "auth_config.json"), "w"
-        ) as f:
-            json.dump(auth_config, f)
+        server = HTTPServer(port=auth_config["port"])
+        token_data = asyncio.run(server.start(state, code_verifier, self._domain))
+
+        if not token_data:
+            self._console.error(
+                "Authentication failed. Please try again.",
+            )
+
+        return TokenData.model_validate(token_data)
+
+    def _open_browser(self, url: str) -> None:
+        # Try to open browser. Always print the fallback link.
+        webbrowser.open(url, new=1)
+        self._console.link(
+            "If a browser window did not open, please open the following URL in your browser:",
+            url,
+        )

uipath/_cli/_auth/_models.py

@@ -10,17 +10,6 @@ class AuthConfig(TypedDict):
     scope: str
 
 
-class TokenData(TypedDict):
-    """TypedDict for token data structure."""
-
-    access_token: str
-    refresh_token: str
-    expires_in: int
-    token_type: str
-    scope: str
-    id_token: str
-
-
 class AccessTokenData(TypedDict):
     """TypedDict for access token data structure."""
 

uipath/_cli/_auth/_oidc_utils.py

@@ -4,6 +4,7 @@ import json
 import os
 from urllib.parse import urlencode
 
+from .._utils._console import ConsoleLogger
 from ._models import AuthConfig
 from ._url_utils import build_service_url
 
@@ -25,6 +26,22 @@ def get_state_param() -> str:
 
 
 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) -> AuthConfig:
         with open(
@@ -32,7 +49,19 @@ class OidcUtils:
         ) as f:
             auth_config = json.load(f)
 
-        port = auth_config.get("port", 8104)
+        candidates = [
+            int(auth_config.get("port", 8104)),
+            int(auth_config.get("portOptionOne", 8104)),
+            int(auth_config.get("portOptionTwo", 8055)),
+            int(auth_config.get("portOptionThree", 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)

uipath/_cli/_auth/_portal_service.py

@@ -1,24 +1,27 @@
-import os
 import time
 from typing import Optional
 
 import click
 import httpx
 
+from ..._utils._auth import update_env_file
 from ..._utils._ssl_context import get_httpx_client_kwargs
+from ...models.auth import TokenData
+from .._runtime._contracts import UiPathErrorCategory, UiPathRuntimeError
 from .._utils._console import ConsoleLogger
-from ._models import TenantsAndOrganizationInfoResponse, TokenData
+from ._models import (
+    OrganizationInfo,
+    TenantInfo,
+    TenantsAndOrganizationInfoResponse,
+)
 from ._oidc_utils import OidcUtils
-from ._url_utils import build_service_url, get_base_url
+from ._url_utils import build_service_url
 from ._utils import (
     get_auth_data,
     get_parsed_token_data,
     update_auth_file,
-    update_env_file,
 )
 
-console = ConsoleLogger()
-
 
 class PortalService:
     """Service for interacting with the UiPath Portal API."""
@@ -29,7 +32,6 @@ class PortalService:
     selected_tenant: Optional[str] = None
 
     _client: Optional[httpx.Client] = None
-
     _tenants_and_organizations: Optional[TenantsAndOrganizationInfoResponse] = None
 
     def __init__(
@@ -41,8 +43,15 @@ class PortalService:
         self.domain = domain
         self.access_token = access_token
         self.prt_id = prt_id
+        self._console = ConsoleLogger()
+        self._tenants_and_organizations = None
+        self._client = None
 
-        self._client = httpx.Client(**get_httpx_client_kwargs())
+    @property
+    def client(self) -> httpx.Client:
+        if self._client is None:
+            self._client = httpx.Client(**get_httpx_client_kwargs())
+        return self._client
 
     def close(self):
         """Explicitly close the HTTP client."""
@@ -59,48 +68,35 @@ class PortalService:
         self.close()
 
     def update_token_data(self, token_data: TokenData):
-        self.access_token = token_data["access_token"]
+        self.access_token = token_data.access_token
         self.prt_id = get_parsed_token_data(token_data).get("prt_id")
+        update_auth_file(token_data)
 
-    def get_tenants_and_organizations(self) -> TenantsAndOrganizationInfoResponse:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+    def get_tenants_and_organizations(
+        self,
+    ):
+        if self._tenants_and_organizations is not None:
+            return self._tenants_and_organizations
 
         url = build_service_url(
             self.domain,
             f"/{self.prt_id}/portal_/api/filtering/leftnav/tenantsAndOrganizationInfo",
         )
-        response = self._client.get(
+        response = self.client.get(
             url, headers={"Authorization": f"Bearer {self.access_token}"}
         )
         if response.status_code < 400:
-            result = response.json()
-            self._tenants_and_organizations = result
-            return result
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(
-                f"Failed to get tenants and organizations: {response.status_code} {response.text}"
-            )
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to get tenants")
+            self._tenants_and_organizations = response.json()
+            return self._tenants_and_organizations
 
-    def get_uipath_orchestrator_url(self) -> str:
-        if self._tenants_and_organizations is None:
-            self._tenants_and_organizations = self.get_tenants_and_organizations()
-        organization = self._tenants_and_organizations.get("organization")
-        if organization is None:
-            console.error("Organization not found.")
-            return ""
-        account_name = organization.get("name")
-        base_url = get_base_url(self.domain)
-        return f"{base_url}/{account_name}/{self.selected_tenant}/orchestrator_"
+        if response.status_code == 401:
+            self._console.error("Unauthorized")
 
-    def post_refresh_token_request(self, refresh_token: str) -> TokenData:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+        self._console.error(
+            f"Failed to get tenants and organizations: {response.status_code} {response.text}"
+        )
 
+    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")
 
@@ -111,16 +107,14 @@ class PortalService:
         }
 
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        response = self._client.post(url, data=data, headers=headers)
+        response = self.client.post(url, data=data, headers=headers)
         if response.status_code < 400:
-            return response.json()
-        elif response.status_code == 401:
-            console.error("Unauthorized")
-        else:
-            console.error(f"Failed to refresh token: {response.status_code}")
-        # Can't reach here, console.error exits, linting
-        raise Exception("Failed to refresh get token")
+            return TokenData.model_validate(response.json())
+
+        if response.status_code == 401:
+            self._console.error("Unauthorized")
+
+        self._console.error(f"Failed to refresh token: {response.status_code}")
 
     def ensure_valid_token(self):
         """Ensure the access token is valid and refresh it if necessary.
@@ -136,127 +130,101 @@ class PortalService:
         auth_data = get_auth_data()
         claims = get_parsed_token_data(auth_data)
         exp = claims.get("exp")
-        if exp is not None and float(exp) > time.time():
-            if not os.getenv("UIPATH_URL"):
-                tenants_and_organizations = self.get_tenants_and_organizations()
-                select_tenant(
-                    self.domain if self.domain else "alpha", tenants_and_organizations
-                )
-            updated_env_contents = {
-                "UIPATH_ACCESS_TOKEN": auth_data["access_token"],
-            }
-        else:
-            refresh_token = auth_data.get("refresh_token")
-            if refresh_token is None:
-                raise Exception("Refresh token not found")
-            token_data = self.post_refresh_token_request(refresh_token)
-            update_auth_file(token_data)
-
-            self.access_token = token_data["access_token"]
-            self.prt_id = claims.get("prt_id")
-
-            updated_env_contents = {
-                "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-            }
-            if not os.getenv("UIPATH_URL"):
-                tenants_and_organizations = self.get_tenants_and_organizations()
-                select_tenant(
-                    self.domain if self.domain else "alpha", tenants_and_organizations
-                )
 
-        update_env_file(updated_env_contents)
+        def finalize(token_data: TokenData):
+            self.update_token_data(token_data)
+            update_env_file({"UIPATH_ACCESS_TOKEN": token_data.access_token})
 
-    def post_auth(self, base_url: str) -> None:
-        if self._client is None:
-            raise RuntimeError("HTTP client is not initialized")
+        if exp is not None and float(exp) > time.time():
+            finalize(auth_data)
+            return
+
+        refresh_token = auth_data.refresh_token
+        if not refresh_token:
+            raise UiPathRuntimeError(
+                "REFRESH_TOKEN_MISSING",
+                "No refresh token found",
+                "The refresh token could not be retrieved. Please retry authenticating.",
+                UiPathErrorCategory.SYSTEM,
+            )
 
-        or_base_url = (
-            f"{base_url}/orchestrator_"
-            if base_url
-            else self.get_uipath_orchestrator_url()
-        )
+        token_data = self.refresh_access_token(refresh_token)
+        finalize(token_data)
 
-        url_try_enable_first_run = f"{or_base_url}/api/StudioWeb/TryEnableFirstRun"
-        url_acquire_license = f"{or_base_url}/api/StudioWeb/AcquireLicense"
+    def enable_studio_web(self, base_url: str) -> None:
+        or_base_url = self.build_orchestrator_url(base_url)
 
-        try:
-            [try_enable_first_run_response, acquire_license_response] = [
-                self._client.post(
-                    url,
-                    headers={"Authorization": f"Bearer {self.access_token}"},
-                )
-                for url in [url_try_enable_first_run, url_acquire_license]
-            ]
-        except Exception:
-            pass
-
-    def has_initialized_auth(self):
-        try:
-            auth_data = get_auth_data()
-            if not auth_data or "access_token" not in auth_data:
-                return False
-            if not os.path.exists(".env"):
-                return False
-            if not os.getenv("UIPATH_ACCESS_TOKEN"):
-                return False
-
-            return True
-        except Exception:
-            return False
-
-
-def select_tenant(
-    domain: str, tenants_and_organizations: TenantsAndOrganizationInfoResponse
-):
-    tenant_names = [tenant["name"] for tenant in tenants_and_organizations["tenants"]]
-    console.display_options(tenant_names, "Select tenant:")
-    tenant_idx = (
-        0
-        if len(tenant_names) == 1
-        else console.prompt("Select tenant number", type=int)
-    )
-    tenant_name = tenant_names[tenant_idx]
-    account_name = tenants_and_organizations["organization"]["name"]
-    console.info(f"Selected tenant: {click.style(tenant_name, fg='cyan')}")
-
-    base_url = get_base_url(domain)
-    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
-
-    update_env_file(
-        {
-            "UIPATH_URL": uipath_url,
-            "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
-            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
-        }
-    )
+        urls = [
+            f"{or_base_url}/api/StudioWeb/TryEnableFirstRun",
+            f"{or_base_url}/api/StudioWeb/AcquireLicense",
+        ]
 
-    return uipath_url
+        for url in urls:
+            try:
+                resp = self.client.post(
+                    url, headers={"Authorization": f"Bearer {self.access_token}"}
+                )
+                if resp.status_code >= 400:
+                    self._console.warning(f"Call to {url} failed: {resp.status_code}")
+            except httpx.HTTPError as e:
+                self._console.warning(
+                    f"Exception during enable_studio_web request to {url}: {e}"
+                )
 
+    def _set_tenant(self, tenant: TenantInfo, organization: OrganizationInfo):
+        self.selected_tenant = tenant["name"]
+        return {"tenant_id": tenant["id"], "organization_id": organization["id"]}
 
-def get_tenant_id(
-    domain: str,
-    tenant_name: str,
-    tenants_and_organizations: TenantsAndOrganizationInfoResponse,
-) -> str:
-    tenants = tenants_and_organizations["tenants"]
+    def _select_tenant(self):
+        data = self.get_tenants_and_organizations()
+        organization = data["organization"]
+        tenants = data["tenants"]
 
-    matched_tenant = next((t for t in tenants if t["name"] == tenant_name), None)
-    if not matched_tenant:
-        console.error(f"Tenant '{tenant_name}' not found.")
-        raise ValueError(f"Tenant '{tenant_name}' not found.")
+        tenant_names = [tenant["name"] for tenant in tenants]
 
-    domain = get_base_url(domain)
-    account_name = tenants_and_organizations["organization"]["name"]
+        self._console.display_options(tenant_names, "Select tenant:")
+        tenant_idx = (
+            0
+            if len(tenant_names) == 1
+            else self._console.prompt("Select tenant number", type=int)
+        )
 
-    base_url = get_base_url(domain)
-    uipath_url = f"{base_url}/{account_name}/{tenant_name}"
+        tenant = data["tenants"][tenant_idx]
 
-    update_env_file(
-        {
-            "UIPATH_URL": uipath_url,
-            "UIPATH_TENANT_ID": matched_tenant["id"],
-            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
-        }
-    )
+        self._console.info(f"Selected tenant: {click.style(tenant['name'], fg='cyan')}")
+        return self._set_tenant(tenant, organization)
 
-    return uipath_url
+    def _retrieve_tenant(
+        self,
+        tenant_name: str,
+    ):
+        data = self.get_tenants_and_organizations()
+        organization = data["organization"]
+        tenants = data["tenants"]
+
+        tenant = next((t for t in tenants if t["name"] == tenant_name), None)
+        if not tenant:
+            self._console.error(f"Tenant '{tenant_name}' not found.")
+
+        return self._set_tenant(tenant, organization)  # type: ignore
+
+    def resolve_tenant_info(self, tenant: Optional[str] = None):
+        if tenant:
+            return self._retrieve_tenant(tenant)
+        return self._select_tenant()
+
+    def build_tenant_url(self) -> str:
+        data = self.get_tenants_and_organizations()
+        organization_name = data["organization"]["name"]
+        return f"{self.domain}/{organization_name}/{self.selected_tenant}"
+
+    def build_orchestrator_url(self, base_url: str) -> str:
+        if base_url:
+            return f"{base_url}/orchestrator_"
+        data = self.get_tenants_and_organizations()
+        organization = data.get("organization")
+        if organization is None:
+            self._console.error("Organization not found.")
+            return ""
+        organization_name = organization.get("name")
+        return f"{self.domain}/{organization_name}/{self.selected_tenant}/orchestrator_"

uipath/_cli/_auth/_url_utils.py

@@ -1,51 +1,85 @@
 import os
+from typing import Optional, Tuple
 from urllib.parse import urlparse
 
-ignore_env_var = False
+from .._utils._console import ConsoleLogger
 
+console = ConsoleLogger()
 
-def get_base_url(domain: str) -> str:
-    """Get the base URL for UiPath services.
+
+def resolve_domain(
+    base_url: Optional[str], environment: Optional[str], force: bool = False
+) -> str:
+    """Resolve the UiPath domain, giving priority to base_url when valid.
 
     Args:
-        domain: Either a domain name (e.g., 'cloud', 'alpha') or a full URL from UIPATH_URL
+        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.
 
     Returns:
-        The base URL to use for UiPath services
+        A valid base URL for UiPath services.
     """
-    global ignore_env_var
-
-    if not ignore_env_var:
-        # If UIPATH_URL is set and domain is 'cloud' (default), use the base from UIPATH_URL
+    if not force:
+        # If UIPATH_URL is set, prefer its domain
         uipath_url = os.getenv("UIPATH_URL")
-        if uipath_url and domain == "cloud":
-            parsed_url = urlparse(uipath_url)
-            return f"{parsed_url.scheme}://{parsed_url.netloc}"
-
-    # If domain is already a full URL, use it directly
-    if domain.startswith("http"):
-        return domain
-
-    # Otherwise, construct the URL using the domain
-    return f"https://{domain if domain else 'cloud'}.uipath.com"
+        if uipath_url and environment == "cloud":
+            parsed = urlparse(uipath_url)
+            if parsed.scheme and parsed.netloc:
+                domain = f"{parsed.scheme}://{parsed.netloc}"
+                return domain
+            else:
+                console.error(
+                    f"Malformed UIPATH_URL: '{uipath_url}'. "
+                    "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
 
-def set_force_flag(force: bool):
-    global ignore_env_var
-    ignore_env_var = force
+    # Otherwise, fall back to environment
+    return f"https://{environment or 'cloud'}.uipath.com"
 
 
 def build_service_url(domain: str, path: str) -> str:
     """Build a service URL by combining the base URL with a path.
 
     Args:
-        domain: Either a domain name or full URL
+        domain: The domain name
         path: The path to append (should start with /)
 
     Returns:
         The complete service URL
     """
-    base_url = get_base_url(domain)
-    # Remove trailing slash from base_url to avoid double slashes
-    base_url = base_url.rstrip("/")
-    return f"{base_url}{path}"
+    return f"{domain}{path}"
+
+
+def extract_org_tenant(uipath_url: str) -> Tuple[Optional[str], Optional[str]]:
+    """Extract organization and tenant from a UiPath URL.
+
+    Accepts values like:
+      - https://cloud.uipath.com/myOrg/myTenant
+      - https://alpha.uipath.com/myOrg/myTenant/anything_else
+      - cloud.uipath.com/myOrg/myTenant  (scheme will be assumed https)
+
+    Args:
+        uipath_url: The UiPath URL to parse
+
+    Returns:
+        A tuple of (organization, tenant) where:
+          - organization: 'myOrg' or None
+          - tenant: 'myTenant' or None
+
+    Example:
+        >>> extract_org_tenant('https://cloud.uipath.com/myOrg/myTenant')
+        ('myOrg', 'myTenant')
+    """
+    parsed = urlparse(uipath_url if "://" in uipath_url else f"https://{uipath_url}")
+    parts = [p for p in parsed.path.split("/") if p]
+    org = parts[0] if len(parts) >= 1 else None
+    tenant = parts[1] if len(parts) >= 2 else None
+    return org, tenant

uipath/_cli/_auth/_utils.py

@@ -1,51 +1,28 @@
-import base64
 import json
 import os
 from pathlib import Path
 from typing import Optional
 
-from ._models import AccessTokenData, TokenData
+from ..._utils._auth import parse_access_token
+from ...models.auth import TokenData
+from ._models import AccessTokenData
 
 
 def update_auth_file(token_data: TokenData):
     os.makedirs(Path.cwd() / ".uipath", exist_ok=True)
     auth_file = Path.cwd() / ".uipath" / ".auth.json"
     with open(auth_file, "w") as f:
-        json.dump(token_data, f)
+        json.dump(token_data.model_dump(exclude_none=True), f)
 
 
 def get_auth_data() -> TokenData:
     auth_file = Path.cwd() / ".uipath" / ".auth.json"
     if not auth_file.exists():
         raise Exception("No authentication file found")
-    return json.load(open(auth_file))
-
-
-def parse_access_token(access_token: str) -> AccessTokenData:
-    token_parts = access_token.split(".")
-    if len(token_parts) < 2:
-        raise Exception("Invalid access token")
-    payload = base64.urlsafe_b64decode(
-        token_parts[1] + "=" * (-len(token_parts[1]) % 4)
-    )
-    return json.loads(payload)
+    return TokenData.model_validate(json.load(open(auth_file)))
 
 
 def get_parsed_token_data(token_data: Optional[TokenData] = None) -> AccessTokenData:
     if not token_data:
         token_data = get_auth_data()
-    return parse_access_token(token_data["access_token"])
-
-
-def update_env_file(env_contents):
-    env_path = Path.cwd() / ".env"
-    if env_path.exists():
-        with open(env_path, "r") as f:
-            for line in f:
-                if "=" in line:
-                    key, value = line.strip().split("=", 1)
-                    if key not in env_contents:
-                        env_contents[key] = value
-    lines = [f"{key}={value}\n" for key, value in env_contents.items()]
-    with open(env_path, "w") as f:
-        f.writelines(lines)
+    return parse_access_token(token_data.access_token)

uipath/_cli/_utils/_common.py

@@ -12,19 +12,19 @@ from ..spinner import Spinner
 def environment_options(function):
     function = click.option(
         "--alpha",
-        "domain",
+        "environment",
         flag_value="alpha",
         help="Use alpha environment",
     )(function)
     function = click.option(
         "--staging",
-        "domain",
+        "environment",
         flag_value="staging",
         help="Use staging environment",
     )(function)
     function = click.option(
         "--cloud",
-        "domain",
+        "environment",
         flag_value="cloud",
         default=True,
         help="Use production environment",

uipath/_cli/cli_auth.py

@@ -48,7 +48,7 @@ console = ConsoleLogger()
 )
 @track
 def auth(
-    domain,
+    environment: str,
     force: bool = False,
     client_id: Optional[str] = None,
     client_secret: Optional[str] = None,
@@ -70,7 +70,7 @@ def auth(
     - Set UIPATH_DISABLE_SSL_VERIFY to disable SSL verification (not recommended)
     """
     auth_service = AuthService(
-        domain,
+        environment=environment,
         force=force,
         client_id=client_id,
         client_secret=client_secret,

uipath/_services/__init__.py

@@ -7,6 +7,7 @@ from .connections_service import ConnectionsService
 from .context_grounding_service import ContextGroundingService
 from .documents_service import DocumentsService
 from .entities_service import EntitiesService
+from .external_application_service import ExternalApplicationService
 from .folder_service import FolderService
 from .jobs_service import JobsService
 from .llm_gateway_service import UiPathLlmChatService, UiPathOpenAIService
@@ -29,4 +30,5 @@ __all__ = [
     "UiPathLlmChatService",
     "FolderService",
     "EntitiesService",
+    "ExternalApplicationService",
 ]

uipath/{_cli/_auth/_client_credentials.py → _services/external_application_service.py}

@@ -1,22 +1,26 @@
-from typing import Optional, cast
+from os import environ as env
+from typing import Optional
 from urllib.parse import urlparse
 
 import httpx
+from httpx import HTTPStatusError, Request
 
-from ..._utils._ssl_context import get_httpx_client_kwargs
-from .._utils._console import ConsoleLogger
-from ._models import TokenData
-from ._utils import parse_access_token, update_env_file
+from .._utils._ssl_context import get_httpx_client_kwargs
+from .._utils.constants import ENV_BASE_URL
+from ..models.auth import TokenData
+from ..models.exceptions import EnrichedException
 
-console = ConsoleLogger()
 
-
-class ClientCredentialsService:
+class ExternalApplicationService:
     """Service for client credentials authentication flow."""
 
-    def __init__(self, base_url: str):
-        self._base_url = base_url
-        self._domain = self._extract_domain_from_base_url(base_url)
+    def __init__(self, base_url: Optional[str]):
+        if not (resolved_base_url := (base_url or env.get(ENV_BASE_URL))):
+            raise ValueError(
+                "Base URL must be set either via constructor or the BASE_URL environment variable."
+            )
+        self._base_url = resolved_base_url
+        self._domain = self._extract_environment_from_base_url(self._base_url)
 
     def get_token_url(self) -> str:
         """Get the token URL for the specified domain."""
@@ -40,7 +44,7 @@ class ClientCredentialsService:
         """
         return hostname == domain or hostname.endswith(f".{domain}")
 
-    def _extract_domain_from_base_url(self, base_url: str) -> str:
+    def _extract_environment_from_base_url(self, base_url: str) -> str:
         """Extract domain from base URL.
 
         Args:
@@ -70,9 +74,9 @@ class ClientCredentialsService:
             # Default to cloud if parsing fails
             return "cloud"
 
-    def authenticate(
+    def get_token_data(
         self, client_id: str, client_secret: str, scope: Optional[str] = "OR.Execution"
-    ) -> None:
+    ) -> TokenData:
         """Authenticate using client credentials flow.
 
         Args:
@@ -81,7 +85,7 @@ class ClientCredentialsService:
             scope: The scope for the token (default: OR.Execution)
 
         Returns:
-            Token data if successful, None otherwise
+            Token data if successful
         """
         token_url = self.get_token_url()
 
@@ -97,49 +101,40 @@ class ClientCredentialsService:
                 response = client.post(token_url, data=data)
                 match response.status_code:
                     case 200:
-                        token_data = response.json()
-                        token_data = cast(
-                            TokenData,
-                            {
-                                "access_token": token_data["access_token"],
-                                "token_type": token_data.get("token_type", "Bearer"),
-                                "expires_in": token_data.get("expires_in", 3600),
-                                "scope": token_data.get("scope", scope),
-                                "refresh_token": "",
-                                "id_token": "",
-                            },
-                        )
-                        self._setup_environment(token_data)
+                        return TokenData.model_validate(response.json())
                     case 400:
-                        console.error(
-                            "Invalid client credentials or request parameters."
+                        raise EnrichedException(
+                            HTTPStatusError(
+                                message="Invalid client credentials or request parameters.",
+                                request=Request(
+                                    data=data, url=token_url, method="post"
+                                ),
+                                response=response,
+                            )
                         )
                     case 401:
-                        console.error("Unauthorized: Invalid client credentials.")
+                        raise EnrichedException(
+                            HTTPStatusError(
+                                message="Unauthorized: Invalid client credentials.",
+                                request=Request(
+                                    data=data, url=token_url, method="post"
+                                ),
+                                response=response,
+                            )
+                        )
                     case _:
-                        console.error(
-                            f"Authentication failed: {response.status_code} - {response.text}"
+                        raise EnrichedException(
+                            HTTPStatusError(
+                                message=f"Authentication failed with unexpected status: {response.status_code}",
+                                request=Request(
+                                    data=data, url=token_url, method="post"
+                                ),
+                                response=response,
+                            )
                         )
-
+        except EnrichedException:
+            raise
         except httpx.RequestError as e:
-            console.error(f"Network error during authentication: {e}")
+            raise Exception(f"Network error during authentication: {e}") from e
         except Exception as e:
-            console.error(f"Unexpected error during authentication: {e}")
-
-    def _setup_environment(self, token_data: TokenData):
-        """Setup environment variables for client credentials authentication.
-
-        Args:
-            token_data: The token data from authentication
-            base_url: The base URL for the UiPath instance
-        """
-        parsed_access_token = parse_access_token(token_data["access_token"])
-
-        env_vars = {
-            "UIPATH_ACCESS_TOKEN": token_data["access_token"],
-            "UIPATH_URL": self._base_url,
-            "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
-            "UIPATH_TENANT_ID": "",
-        }
-
-        update_env_file(env_vars)
+            raise Exception(f"Unexpected error during authentication: {e}") from e

uipath/_uipath.py

@@ -1,4 +1,3 @@
-from os import environ as env
 from typing import Optional
 
 from pydantic import ValidationError
@@ -23,11 +22,7 @@ from ._services import (
     UiPathOpenAIService,
 )
 from ._utils import setup_logging
-from ._utils.constants import (
-    ENV_BASE_URL,
-    ENV_UIPATH_ACCESS_TOKEN,
-    ENV_UNATTENDED_USER_ACCESS_TOKEN,
-)
+from ._utils._auth import resolve_config
 from .models.errors import BaseUrlMissingError, SecretMissingError
 
 
@@ -37,19 +32,18 @@ class UiPath:
         *,
         base_url: Optional[str] = None,
         secret: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        scope: Optional[str] = None,
         debug: bool = False,
     ) -> None:
-        base_url_value = base_url or env.get(ENV_BASE_URL)
-        secret_value = (
-            secret
-            or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
-            or env.get(ENV_UIPATH_ACCESS_TOKEN)
-        )
-
         try:
+            base_url, secret = resolve_config(
+                base_url, secret, client_id, client_secret, scope
+            )
             self._config = Config(
-                base_url=base_url_value,  # type: ignore
-                secret=secret_value,  # type: ignore
+                base_url=base_url,
+                secret=secret,
             )
         except ValidationError as e:
             for error in e.errors():

uipath/_utils/_auth.py

@@ -0,0 +1,82 @@
+import base64
+import json
+from os import environ as env
+from pathlib import Path
+from typing import Optional
+
+from .._services import ExternalApplicationService
+from .constants import (
+    ENV_BASE_URL,
+    ENV_UIPATH_ACCESS_TOKEN,
+    ENV_UNATTENDED_USER_ACCESS_TOKEN,
+)
+
+
+def parse_access_token(access_token: str):
+    token_parts = access_token.split(".")
+    if len(token_parts) < 2:
+        raise Exception("Invalid access token")
+    payload = base64.urlsafe_b64decode(
+        token_parts[1] + "=" * (-len(token_parts[1]) % 4)
+    )
+    return json.loads(payload)
+
+
+def update_env_file(env_contents):
+    env_path = Path.cwd() / ".env"
+    if env_path.exists():
+        with open(env_path, "r") as f:
+            for line in f:
+                if "=" in line:
+                    key, value = line.strip().split("=", 1)
+                    if key not in env_contents:
+                        env_contents[key] = value
+    lines = [f"{key}={value}\n" for key, value in env_contents.items()]
+    with open(env_path, "w") as f:
+        f.writelines(lines)
+
+
+def _has_valid_client_credentials(
+    client_id: Optional[str], client_secret: Optional[str]
+) -> bool:
+    if bool(client_id) != bool(client_secret):
+        raise ValueError(
+            "Both client_id and client_secret must be provided together for Client Credentials Authentication."
+        )
+    return bool(client_id and client_secret)
+
+
+def resolve_config(
+    base_url: Optional[str],
+    secret: Optional[str],
+    client_id: Optional[str],
+    client_secret: Optional[str],
+    scope: Optional[str],
+):
+    if _has_valid_client_credentials(client_id, client_secret):
+        external_app_service = ExternalApplicationService(base_url)
+        token_data = external_app_service.get_token_data(
+            client_id,  # type: ignore
+            client_secret,  # type: ignore
+            scope,
+        )
+        parsed_access_token = parse_access_token(token_data.access_token)
+
+        env_vars = {
+            "UIPATH_ACCESS_TOKEN": token_data.access_token,
+            "UIPATH_URL": external_app_service._base_url,
+            "UIPATH_ORGANIZATION_ID": parsed_access_token.get("prt_id", ""),
+        }
+
+        update_env_file(env_vars)
+        return external_app_service._base_url, token_data.access_token
+
+    base_url_value = base_url or env.get(ENV_BASE_URL)
+
+    secret_value = (
+        secret
+        or env.get(ENV_UNATTENDED_USER_ACCESS_TOKEN)
+        or env.get(ENV_UIPATH_ACCESS_TOKEN)
+    )
+
+    return base_url_value, secret_value

uipath/models/auth.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class TokenData(BaseModel):
+    """Pydantic model for token data structure."""
+
+    access_token: str
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+    token_type: Optional[str] = None
+    scope: Optional[str] = None
+    id_token: Optional[str] = None

{uipath-2.1.80.dist-info → uipath-2.1.81.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.80
+Version: 2.1.81
 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.80.dist-info → uipath-2.1.81.dist-info}/RECORD

@@ -2,11 +2,11 @@ uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
 uipath/_config.py,sha256=pi3qxPzDTxMEstj_XkGOgKJqD6RTHHv7vYv8sS_-d5Q,92
 uipath/_execution_context.py,sha256=Qo8VMUFgtiL-40KsZrvul5bGv1CRERle_fCw1ORCggY,2374
 uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,1861
-uipath/_uipath.py,sha256=xvBwczfjrvrB96ZK7wo0IgDcPDQWuEqu4dioH9CKd4k,5021
+uipath/_uipath.py,sha256=mhtdu36-A-2WhPGNFFrTmQWbE07Bn4IV_Vrqgf6kuVM,4900
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=2RUgXYd8uJaYjA67xWb0w4IZuBmZoY8G1ccNmEQk9oM,2343
-uipath/_cli/cli_auth.py,sha256=ZEA0Fwoo77Ez9ctpRAIq7sbAwj8F4OouAbMp1g1OvjM,2601
+uipath/_cli/cli_auth.py,sha256=CzetSRqSUvMs02PtI4w5Vi_0fv_ETA307bB2vXalWzY,2628
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
 uipath/_cli/cli_eval.py,sha256=oOMywGSUrHDQ1W_54ccbekzCeduPf-KHRyu_r0Dezd0,5444
@@ -21,13 +21,12 @@ uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
 uipath/_cli/middlewares.py,sha256=0D9a-wphyetnH9T97F08o7-1OKWF1lMweFHHAR0xiOw,4979
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=22km0F1NFNXgyLbvtAx3ssiQlVGHroLdtDCWEqiCiMg,7106
-uipath/_cli/_auth/_auth_service.py,sha256=Thtp2wXZQAHqossPPXuP6sAEe4Px9xThhZutMECRrdU,6386
-uipath/_cli/_auth/_client_credentials.py,sha256=VIyzgnGHSZxJXG8kSFIcCH0n2K2zep2SYcb5q1nBFcs,5408
-uipath/_cli/_auth/_models.py,sha256=sYMCfvmprIqnZxStlD_Dxx2bcxgn0Ri4D7uwemwkcNg,948
-uipath/_cli/_auth/_oidc_utils.py,sha256=j9VCXai_dM9PF1WtoWEsXETvrWUjuTgU-dCJ3oRudyg,2394
-uipath/_cli/_auth/_portal_service.py,sha256=vP82BhjA2D6E6y2wDcXqO1cM4thhPl6DeGsnNXCBdhA,9144
-uipath/_cli/_auth/_url_utils.py,sha256=Vr-eYbwW_ltmwkULNEAbn6LNsMHnT4uT1n_1zlqD4Ss,1503
-uipath/_cli/_auth/_utils.py,sha256=9nb76xe5XmDZ0TAncp-_1SKqL6FdwRi9eS3C2noN1lY,1591
+uipath/_cli/_auth/_auth_service.py,sha256=7UykDSZWhe8B152rnoS1wF0XkAkhAipfDwEtT2cW7rk,5245
+uipath/_cli/_auth/_models.py,sha256=kWhqd5FqBo_oi3DW2x1IaJHsEloXq0I24f-pX5zb_O4,753
+uipath/_cli/_auth/_oidc_utils.py,sha256=SLiOOAEdVwmPKRxIhFkARnNbrf01tvJxBAxa6MF9HHY,3458
+uipath/_cli/_auth/_portal_service.py,sha256=sq3Ls7v8Q1gQWbYlE37_p82gLYPhC_cXJRTuIxMsCPU,7997
+uipath/_cli/_auth/_url_utils.py,sha256=MuMYesMQDgetLBzkwd19dPxw3fctys7EVpByDUQMyLE,2844
+uipath/_cli/_auth/_utils.py,sha256=To4Ara_UF4g7nzUfKqFA11lTjhQWIZWNm4xwa5nNKmU,896
 uipath/_cli/_auth/auth_config.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0QvcUX8,521
 uipath/_cli/_auth/index.html,sha256=uGK0CDTP8Rys_p4O_Pbd2x4tz0frKNVcumjrXnal5Nc,22814
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
@@ -73,7 +72,7 @@ uipath/_cli/_templates/.rels.template,sha256=-fTcw7OA1AcymHr0LzBqbMAAtzZTRXLTNa_
 uipath/_cli/_templates/[Content_Types].xml.template,sha256=bYsKDz31PkIF9QksjgAY_bqm57YC8U_owsZeNZAiBxQ,584
 uipath/_cli/_templates/main.py.template,sha256=QB62qX5HKDbW4lFskxj7h9uuxBITnTWqu_DE6asCwcU,476
 uipath/_cli/_templates/package.nuspec.template,sha256=YZyLc-u_EsmIoKf42JsLQ55OGeFmb8VkIU2VF7DFbtw,359
-uipath/_cli/_utils/_common.py,sha256=CzhhkIRfCuQ1-5HLDtjzOyt8KFs1jm6wzrBeU_v2B7c,3329
+uipath/_cli/_utils/_common.py,sha256=bYgqIdlxxlB_4s8BlZsfGbSdbfm93MFtOj5ydptbkPI,3344
 uipath/_cli/_utils/_console.py,sha256=scvnrrFoFX6CE451K-PXKV7UN0DUkInbOtDZ5jAdPP0,10070
 uipath/_cli/_utils/_constants.py,sha256=rS8lQ5Nzull8ytajK6lBsz398qiCp1REoAwlHtyBwF0,1415
 uipath/_cli/_utils/_debug.py,sha256=zamzIR4VgbdKADAE4gbmjxDsbgF7wvdr7C5Dqp744Oc,1739
@@ -90,7 +89,7 @@ uipath/_events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,5496
 uipath/_events/_events.py,sha256=EzDfzpVm-EIH27Onad5mo8Go6-WB3S6_-6zZQ7qV58w,1811
 uipath/_resources/AGENTS.md,sha256=YWhWuX9XIbyVhVT3PnPc4Of3_q6bsNJcuzYu3N8f_Ug,25850
-uipath/_services/__init__.py,sha256=eYZElMfYDQTQU6MMjIke5J-GGT9pzLD5QfbwLiTQkEE,1037
+uipath/_services/__init__.py,sha256=_LNy4u--VlhVtTO66bULbCoBjyJBTuyh9jnzjWrv-h4,1140
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
 uipath/_services/api_client.py,sha256=kGm04ijk9AOEQd2BMxvQg-2QoB8dmyoDwFFDPyutAGw,1966
@@ -101,12 +100,14 @@ uipath/_services/connections_service.py,sha256=IqhKdRYwNZlRsDL2vY7gyl5nAiYaK1zvj
 uipath/_services/context_grounding_service.py,sha256=Pjx-QQQEiSKD-hY6ityj3QUSALN3fIcKLLHr_NZ0d_g,37117
 uipath/_services/documents_service.py,sha256=UnFS8EpOZ_Ng2TZk3OiJJ3iNANvFs7QxuoG_v-lQj6c,24815
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
+uipath/_services/external_application_service.py,sha256=gZhnGgLn7ZYUZzZF7AumB14QEPanVY-D_02FqEcAFtw,5478
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
 uipath/_services/jobs_service.py,sha256=tTZNsdZKN3uP7bWPQyBCpJeQxTfuOWbKYOR4L-_yJo4,32736
 uipath/_services/llm_gateway_service.py,sha256=oFBKSYbZqujGHDuM3A72S3J7mHn9kWjNTgcE3U0c24Y,24411
 uipath/_services/processes_service.py,sha256=O_uHgQ1rnwiV5quG0OQqabAnE6Rf6cWrMENYY2jKWt8,8585
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
 uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
+uipath/_utils/_auth.py,sha256=5R30ALuRrIatf_0Lk-AETJvt6ora7h0R7yeDdliW1Lg,2524
 uipath/_utils/_endpoint.py,sha256=yYHwqbQuJIevpaTkdfYJS9CrtlFeEyfb5JQK5osTCog,2489
 uipath/_utils/_infer_bindings.py,sha256=eCxfUjd37fOFZ6vOfKl2BhWVUt7iSSJ-VQ0-nDTBcaA,1836
 uipath/_utils/_logs.py,sha256=adfX_0UAn3YBeKJ8DQDeZs94rJyHGQO00uDfkaTpNWQ,510
@@ -147,6 +148,7 @@ uipath/models/action_schema.py,sha256=tBn1qQ3NQLU5nwWlBIzIKIx3XK5pO_D1S51IjFlZ1F
 uipath/models/actions.py,sha256=1vRsJ3JSmMdPkbiYAiHzY8K44vmW3VlMsmQUBAkSgrQ,3141
 uipath/models/assets.py,sha256=7x3swJRnG_a4VgjdXKKwraJLT5TF0u4wHsl6coOjX0g,2762
 uipath/models/attachment.py,sha256=lI6BxBY6DY5U6qZbxhkNu-usseA1zovYSTRtLq50ubI,1029
+uipath/models/auth.py,sha256=-CEo5KZVtZZgbAMatN6B1vBmGp8lTTumR8sMthRmL8I,345
 uipath/models/buckets.py,sha256=N3Lj_dVCv709-ywhOOdyCSvsuLn41eGuAfSiik6Q6F8,1285
 uipath/models/connections.py,sha256=bTDg8xISSPmKB1GFNEEMD1OEZyBDFHfZVKqw4gab1pE,2524
 uipath/models/context_grounding.py,sha256=3MaF2Fv2QYle8UUWvKGkCN5XGpx2T4a34fdbBqJ2fCs,1137
@@ -169,8 +171,8 @@ uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,199
 uipath/tracing/_utils.py,sha256=qd7N56tg6VXQ9pREh61esBgUWLNA0ssKsE0QlwrRWFM,11974
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.80.dist-info/METADATA,sha256=AMUh4rPIDQJzkepk6v3LaIpzwfyFraEhCYdN_0Z96YI,6593
-uipath-2.1.80.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.80.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.80.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.80.dist-info/RECORD,,
+uipath-2.1.81.dist-info/METADATA,sha256=8-3eAQ0tiFCXMWOhGm8QTSvM9fATrjo6j-UnceXoMOE,6593
+uipath-2.1.81.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.81.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.81.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.81.dist-info/RECORD,,