uipath 2.1.81__tar.gz → 2.1.83__tar.gz

{uipath-2.1.81 → uipath-2.1.83}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.81"
+version = "2.1.83"
 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.81 → uipath-2.1.83}/src/uipath/_cli/_auth/_auth_server.py

@@ -7,8 +7,6 @@ import threading
 import time
 from typing import Optional
 
-from ._oidc_utils import OidcUtils
-
 # Server port
 PORT = 6234
 
@@ -22,7 +20,9 @@ class TokenReceivedSignal(Exception):
         super().__init__("Token received successfully")
 
 
-def make_request_handler_class(state, code_verifier, token_callback, domain):
+def make_request_handler_class(
+    state, code_verifier, token_callback, domain, redirect_uri, client_id
+):
     class SimpleHTTPSRequestHandler(http.server.SimpleHTTPRequestHandler):
         """Simple HTTPS request handler that serves static files."""
 
@@ -73,16 +73,10 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
                 with open(index_path, "r") as f:
                     content = f.read()
 
-                # Get the redirect URI from auth config
-                auth_config = OidcUtils.get_auth_config()
-                redirect_uri = auth_config["redirect_uri"]
-
                 content = content.replace("__PY_REPLACE_EXPECTED_STATE__", state)
                 content = content.replace("__PY_REPLACE_CODE_VERIFIER__", code_verifier)
                 content = content.replace("__PY_REPLACE_REDIRECT_URI__", redirect_uri)
-                content = content.replace(
-                    "__PY_REPLACE_CLIENT_ID__", auth_config["client_id"]
-                )
+                content = content.replace("__PY_REPLACE_CLIENT_ID__", client_id)
                 content = content.replace("__PY_REPLACE_DOMAIN__", domain)
 
                 self.send_response(200)
@@ -107,14 +101,18 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
 
 
 class HTTPServer:
-    def __init__(self, port=6234):
+    def __init__(self, port=6234, redirect_uri=None, client_id=None):
         """Initialize HTTP server with configurable parameters.
 
         Args:
             port (int, optional): Port number to run the server on. Defaults to 6234.
+            redirect_uri (str, optional): OAuth redirect URI. Defaults to None.
+            client_id (str, optional): OAuth client ID. Defaults to None.
         """
         self.current_path = os.path.dirname(os.path.abspath(__file__))
         self.port = port
+        self.redirect_uri = redirect_uri
+        self.client_id = client_id
         self.httpd: Optional[socketserver.TCPServer] = None
         self.token_data = None
         self.should_shutdown = False
@@ -145,7 +143,12 @@ class HTTPServer:
         # Create server with address reuse
         socketserver.TCPServer.allow_reuse_address = True
         handler = make_request_handler_class(
-            state, code_verifier, self.token_received_callback, domain
+            state,
+            code_verifier,
+            self.token_received_callback,
+            domain,
+            self.redirect_uri,
+            self.client_id,
         )
         self.httpd = socketserver.TCPServer(("", self.port), handler)
         return self.httpd

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/_cli/_auth/_auth_service.py

@@ -121,11 +121,17 @@ class AuthService:
         return False
 
     def _perform_oauth_flow(self) -> TokenData:
-        auth_url, code_verifier, state = OidcUtils.get_auth_url(self._domain)
+        auth_config = OidcUtils.get_auth_config()
+        auth_url, code_verifier, state = OidcUtils.get_auth_url(
+            self._domain, auth_config
+        )
         self._open_browser(auth_url)
 
-        auth_config = OidcUtils.get_auth_config()
-        server = HTTPServer(port=auth_config["port"])
+        server = HTTPServer(
+            port=auth_config["port"],
+            redirect_uri=auth_config["redirect_uri"],
+            client_id=auth_config["client_id"],
+        )
         token_data = asyncio.run(server.start(state, code_verifier, self._domain))
 
         if not token_data:

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/_cli/_auth/_oidc_utils.py

@@ -49,12 +49,8 @@ class OidcUtils:
         ) as f:
             auth_config = json.load(f)
 
-        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)),
-        ]
+        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:
@@ -75,11 +71,12 @@ class OidcUtils:
         )
 
     @classmethod
-    def get_auth_url(cls, domain: str) -> tuple[str, str, str]:
+    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:
@@ -87,7 +84,6 @@ class OidcUtils:
                 - The code verifier for PKCE flow
         """
         code_verifier, code_challenge = generate_code_verifier_and_challenge()
-        auth_config = cls.get_auth_config()
         state = get_state_param()
         query_params = {
             "client_id": auth_config["client_id"],

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/_cli/_evals/_runtime.py

@@ -7,7 +7,8 @@ from pathlib import Path
 from time import time
 from typing import Any, Dict, Generic, List, Optional, Sequence, TypeVar
 
-from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry import context as context_api
+from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
 from ..._events._event_bus import EventBus
@@ -24,6 +25,7 @@ from ...eval.models import EvaluationResult
 from ...eval.models.models import AgentExecution, EvalItemResult
 from .._runtime._contracts import (
     UiPathBaseRuntime,
+    UiPathExecutionBatchTraceProcessor,
     UiPathRuntimeContext,
     UiPathRuntimeFactory,
     UiPathRuntimeResult,
@@ -41,7 +43,11 @@ from ._models._output import (
     UiPathEvalOutput,
     UiPathEvalRunExecutionOutput,
 )
-from .mocks.mocks import set_evaluation_item
+from ._span_collection import ExecutionSpanCollector
+from .mocks.mocks import (
+    clear_execution_context,
+    set_execution_context,
+)
 
 T = TypeVar("T", bound=UiPathBaseRuntime)
 C = TypeVar("C", bound=UiPathRuntimeContext)
@@ -78,6 +84,24 @@ class ExecutionSpanExporter(SpanExporter):
         self.clear()
 
 
+class ExecutionSpanProcessor(UiPathExecutionBatchTraceProcessor):
+    """Span processor that adds spans to ExecutionSpanCollector when they start."""
+
+    def __init__(self, span_exporter: SpanExporter, collector: ExecutionSpanCollector):
+        super().__init__(span_exporter)
+        self.collector = collector
+
+    def on_start(
+        self, span: Span, parent_context: Optional[context_api.Context] = None
+    ) -> None:
+        super().on_start(span, parent_context)
+
+        if span.attributes and "execution.id" in span.attributes:
+            exec_id = span.attributes["execution.id"]
+            if isinstance(exec_id, str):
+                self.collector.add_span(span, exec_id)
+
+
 class ExecutionLogsExporter:
     """Custom exporter that stores multiple execution log handlers."""
 
@@ -127,8 +151,15 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         self.context: UiPathEvalContext = context
         self.factory: UiPathRuntimeFactory[T, C] = factory
         self.event_bus: EventBus = event_bus
+
         self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
-        self.factory.add_span_exporter(self.span_exporter)
+        self.span_collector: ExecutionSpanCollector = ExecutionSpanCollector()
+
+        # Span processor feeds both exporter and collector
+        span_processor = ExecutionSpanProcessor(self.span_exporter, self.span_collector)
+        self.factory.tracer_span_processors.append(span_processor)
+        self.factory.tracer_provider.add_span_processor(span_processor)
+
         self.logs_exporter: ExecutionLogsExporter = ExecutionLogsExporter()
         self.execution_id = str(uuid.uuid4())
 
@@ -180,7 +211,6 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             evaluation_set_name=evaluation_set.name,
             evaluation_set_results=eval_run_result_list,
         )
-
         # Computing evaluator averages
         evaluator_averages: Dict[str, float] = defaultdict(float)
         evaluator_count: Dict[str, int] = defaultdict(int)
@@ -194,7 +224,6 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             evaluator_averages[eval_id] = (
                 evaluator_averages[eval_id] / evaluator_count[eval_id]
             )
-
         await event_bus.publish(
             EvaluationEvents.UPDATE_EVAL_SET_RUN,
             EvalSetRunUpdatedEvent(
@@ -289,7 +318,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         evaluators: List[BaseEvaluator[Any]],
         event_bus: EventBus,
     ) -> EvaluationRunResult:
-        set_evaluation_item(eval_item)
+        set_execution_context(eval_item, self.span_collector)
 
         await event_bus.publish(
             EvaluationEvents.CREATE_EVAL_RUN,
@@ -383,6 +412,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
                 eval_run_updated_event,
                 wait_for_completion=False,
             )
+        finally:
+            clear_execution_context()
 
         return evaluation_run_results
 
@@ -391,6 +422,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     ) -> tuple[List[ReadableSpan], list[logging.LogRecord]]:
         spans = self.span_exporter.get_spans(execution_id)
         self.span_exporter.clear(execution_id)
+        self.span_collector.clear(execution_id)
 
         logs = self.logs_exporter.get_logs(execution_id)
         self.logs_exporter.clear(execution_id)

uipath-2.1.83/src/uipath/_cli/_evals/_span_collection.py

@@ -0,0 +1,24 @@
+from collections import defaultdict
+from typing import Dict, List, Optional
+
+from opentelemetry.sdk.trace import ReadableSpan, Span
+
+
+class ExecutionSpanCollector:
+    """Collects spans as they are created during execution."""
+
+    def __init__(self):
+        # { execution_id -> list of spans }
+        self._spans: Dict[str, List[ReadableSpan]] = defaultdict(list)
+
+    def add_span(self, span: Span, execution_id: str) -> None:
+        self._spans[execution_id].append(span)
+
+    def get_spans(self, execution_id: str) -> List[ReadableSpan]:
+        return self._spans.get(execution_id, [])
+
+    def clear(self, execution_id: Optional[str] = None) -> None:
+        if execution_id:
+            self._spans.pop(execution_id, None)
+        else:
+            self._spans.clear()

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/_cli/_evals/mocks/llm_mocker.py

@@ -6,6 +6,9 @@ from typing import Any, Callable
 
 from pydantic import BaseModel
 
+from uipath.tracing._traced import traced
+from uipath.tracing._utils import _SpanUtils
+
 from .._models._evaluation_set import (
     EvaluationItem,
     LLMMockingStrategy,
@@ -51,7 +54,7 @@ Based on the above information, provide a realistic response for this tool call.
 3. Always include the entire output regardless of token length.
 3. Consider the context of the current test run and the agent being tested.  If the agent is acting on a property, make sure the output includes that property.
 
-Respond ONLY with valid JSON that would be a realistic and completetool response. Do not include any explanations or markdown.
+Respond ONLY with valid JSON that would be a realistic and complete tool response. Do not include any explanations or markdown.
 """
 
 logger = logging.getLogger(__name__)
@@ -79,6 +82,7 @@ class LLMMocker(Mocker):
         self.evaluation_item = evaluation_item
         assert isinstance(self.evaluation_item.mocking_strategy, LLMMockingStrategy)
 
+    @traced(name="__mocker__")
     async def response(
         self, func: Callable[[T], R], params: dict[str, Any], *args: T, **kwargs
     ) -> R:
@@ -92,6 +96,8 @@ class LLMMocker(Mocker):
             from uipath import UiPath
             from uipath._services.llm_gateway_service import _cleanup_schema
 
+            from .mocks import evaluation_context, span_collector_context
+
             llm = UiPath().llm
             return_type: Any = func.__annotations__.get("return", None)
             if return_type is None:
@@ -116,9 +122,17 @@ class LLMMocker(Mocker):
                 example_calls = [
                     call for call in example_calls if isinstance(call, ExampleCall)
                 ]
+
+                test_run_history = "(empty)"
+                eval_item = evaluation_context.get()
+                span_collector = span_collector_context.get()
+                if eval_item and span_collector:
+                    spans = span_collector.get_spans(eval_item.id)
+                    test_run_history = _SpanUtils.spans_to_llm_context(spans)
+
                 prompt_input: dict[str, Any] = {
                     "toolRunExamples": example_calls,
-                    "testRunHistory": [],  # This should contain ordered spans.
+                    "testRunHistory": test_run_history,
                     "toolInfo": {
                         "name": function_name,
                         "description": params.get("description"),

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/_cli/_evals/mocks/mocks.py

@@ -5,30 +5,49 @@ from contextvars import ContextVar
 from typing import Any, Callable, Optional
 
 from uipath._cli._evals._models._evaluation_set import EvaluationItem
+from uipath._cli._evals._span_collection import ExecutionSpanCollector
 from uipath._cli._evals.mocks.mocker import Mocker, UiPathNoMockFoundError
 from uipath._cli._evals.mocks.mocker_factory import MockerFactory
 
+# Context variables for evaluation items and mockers
 evaluation_context: ContextVar[Optional[EvaluationItem]] = ContextVar(
     "evaluation", default=None
 )
 
 mocker_context: ContextVar[Optional[Mocker]] = ContextVar("mocker", default=None)
 
+# Span collector for trace access during mocking
+span_collector_context: ContextVar[Optional[ExecutionSpanCollector]] = ContextVar(
+    "span_collector", default=None
+)
+
 logger = logging.getLogger(__name__)
 
 
-def set_evaluation_item(item: EvaluationItem) -> None:
-    """Set an evaluation item within an evaluation set."""
-    evaluation_context.set(item)
+def set_execution_context(
+    eval_item: EvaluationItem, span_collector: ExecutionSpanCollector
+) -> None:
+    """Set the execution context for an evaluation run for mocking and trace access."""
+    evaluation_context.set(eval_item)
+
     try:
-        if item.mocking_strategy:
-            mocker_context.set(MockerFactory.create(item))
+        if eval_item.mocking_strategy:
+            mocker_context.set(MockerFactory.create(eval_item))
         else:
             mocker_context.set(None)
     except Exception:
-        logger.warning(f"Failed to create mocker for evaluation {item.name}")
+        logger.warning(f"Failed to create mocker for evaluation {eval_item.name}")
         mocker_context.set(None)
 
+    span_collector_context.set(span_collector)
+
+
+def clear_execution_context() -> None:
+    """Clear the execution context after evaluation completes."""
+    evaluation_context.set(None)
+    mocker_context.set(None)
+    span_collector_context.set(None)
+
 
 async def get_mocked_response(
     func: Callable[[Any], Any], params: dict[str, Any], *args, **kwargs

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/telemetry/_track.py

@@ -101,6 +101,7 @@ class _TelemetryClient:
                 disable_offline_storage=True,
             )
 
+            getLogger("azure").setLevel(WARNING)
             _logger.addHandler(_AzureMonitorOpenTelemetryEventHandler())
             _logger.setLevel(WARNING)
 

{uipath-2.1.81 → uipath-2.1.83}/src/uipath/tracing/_utils.py

@@ -319,3 +319,55 @@ class _SpanUtils:
                 f"Error formatting arguments for trace: {e}. Using args and kwargs directly."
             )
             return {"args": args, "kwargs": kwargs}
+
+    @staticmethod
+    def _has_ancestor_with_name(
+        span: ReadableSpan, ancestor_name: str, span_map: Dict[int, ReadableSpan]
+    ) -> bool:
+        """Check if this span or any of its ancestors has a given name."""
+        if span.name == ancestor_name:
+            return True
+
+        current = span
+        while current.parent is not None:
+            parent_span = span_map.get(current.parent.span_id)
+            if parent_span is None:
+                break
+            if parent_span.name == ancestor_name:
+                return True
+            current = parent_span
+
+        return False
+
+    @staticmethod
+    def spans_to_llm_context(spans: list[ReadableSpan]) -> str:
+        """Convert spans to a formatted conversation history string suitable for LLM context.
+
+        Includes function calls (including LLM calls) with their inputs and outputs.
+        """
+        # Build span_id -> span map for parent chain traversal
+        span_map = {span.get_span_context().span_id: span for span in spans}
+
+        history = []
+        for span in spans:
+            attributes = dict(span.attributes) if span.attributes else {}
+
+            input_value = attributes.get("input.value")
+            output_value = attributes.get("output.value")
+
+            if not input_value or not output_value:
+                continue
+
+            # Skip spans that are internal LLM calls (eg. for tool mocking in evals)
+            if _SpanUtils._has_ancestor_with_name(span, "__mocker__", span_map):
+                continue
+
+            history.append(f"Function: {span.name}")
+            history.append(f"Input: {input_value}")
+            history.append(f"Output: {output_value}")
+            history.append("")
+
+        if not history:
+            return "(empty)"
+
+        return "\n".join(history)

{uipath-2.1.81 → uipath-2.1.83}/tests/cli/eval/mocks/test_mocks.py

@@ -1,4 +1,5 @@
 from typing import Any
+from unittest.mock import MagicMock
 
 import pytest
 from _pytest.monkeypatch import MonkeyPatch
@@ -10,9 +11,11 @@ from uipath._cli._evals._models._evaluation_set import (
     MockitoMockingStrategy,
 )
 from uipath._cli._evals.mocks.mocker import UiPathMockResponseGenerationError
-from uipath._cli._evals.mocks.mocks import set_evaluation_item
+from uipath._cli._evals.mocks.mocks import set_execution_context
 from uipath.eval.mocks import mockable
 
+_mock_span_collector = MagicMock()
+
 
 def test_mockito_mockable_sync():
     # Arrange
@@ -51,7 +54,7 @@ def test_mockito_mockable_sync():
     assert isinstance(evaluation.mocking_strategy, MockitoMockingStrategy)
 
     # Act & Assert
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert foo() == "bar1"
     assert foo() == "bar2"
     assert foo() == "bar2"
@@ -63,13 +66,13 @@ def test_mockito_mockable_sync():
         assert foofoo()
 
     evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {"x": 1}
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert foo(x=1) == "bar1"
 
     evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {
         "x": {"_target_": "mockito.any"}
     }
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert foo(x=2) == "bar1"
 
 
@@ -111,7 +114,7 @@ async def test_mockito_mockable_async():
     assert isinstance(evaluation.mocking_strategy, MockitoMockingStrategy)
 
     # Act & Assert
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert await foo() == "bar1"
     assert await foo() == "bar2"
     assert await foo() == "bar2"
@@ -123,13 +126,13 @@ async def test_mockito_mockable_async():
         assert await foofoo()
 
     evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {"x": 1}
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert await foo(x=1) == "bar1"
 
     evaluation.mocking_strategy.behaviors[0].arguments.kwargs = {
         "x": {"_target_": "mockito.any"}
     }
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
     assert await foo(x=2) == "bar1"
 
 
@@ -201,7 +204,7 @@ def test_llm_mockable_sync(httpx_mock: HTTPXMock, monkeypatch: MonkeyPatch):
         },
     )
     # Act & Assert
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
 
     assert foo() == "bar1"
     with pytest.raises(NotImplementedError):
@@ -274,7 +277,7 @@ async def test_llm_mockable_async(httpx_mock: HTTPXMock, monkeypatch: MonkeyPatc
         },
     )
     # Act & Assert
-    set_evaluation_item(evaluation)
+    set_execution_context(evaluation, _mock_span_collector)
 
     assert await foo() == "bar1"
     with pytest.raises(NotImplementedError):

uipath-2.1.83/tests/cli/test_oidc_utils.py

@@ -0,0 +1,96 @@
+"""
+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
+
+
+class TestOidcUtils:
+    """Test suite for OidcUtils class."""
+
+    def test_auth_config_backwards_compatibility_v2025_10(self):
+        """
+        Test that auth_config.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.json file
+        config_path = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "src",
+            "uipath",
+            "_cli",
+            "_auth",
+            "auth_config.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)}"
+        )

{uipath-2.1.81 → uipath-2.1.83}/uv.lock

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