Merge branch 'feat/business-rules-evaluate' into feat/business-rules-run

Brings in #1912's shared run()/run_async() steps. The debug path joins
them: _RunTarget also carries the debug job key (and no folder), decided in
_prepare_run() before the binding, and _run_spec() builds the request for
the endpoint the target names. run() and run_async() stay three steps each.
No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: ashishupadhyay88

packages/uipath-platform/src/uipath/platform/business_rules/_business_rules_service.py

@@ -6,6 +6,7 @@
 
 import unicodedata
 from collections.abc import Mapping
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple
 
 from ..common._base_service import _TRACE_PARENT_HEADER, BaseService
@@ -34,6 +35,21 @@
 _FORBIDDEN_RULE_NAME_PARTS = ("/", "\\", "..", "%")
 
 
+@dataclass(frozen=True)
+class _RunTarget:
+    """Where a run goes, settled before anything is sent.
+
+    A debug run carries ``debug_job_key`` and no folder. A deployed run carries
+    exactly one of ``folder_key`` and ``folder_path``: a key ready to send, or a
+    path still to look up.
+    """
+
+    name: str
+    folder_key: Optional[str] = None
+    folder_path: Optional[str] = None
+    debug_job_key: Optional[str] = None
+
+
 class BusinessRulesService(FolderContext, BaseService):
     """Service for running UiPath Business Rules.
 
@@ -129,32 +145,19 @@ def run(
             )
             ```
         """
-        debug_job_key = _resolve_debug_job_key(folder_key, folder_path)
-        name, folder_key, folder_path = self._apply_binding(
-            name, folder_key, folder_path
-        )
-        _validate_run_arguments(name, input)
-        if debug_job_key:
-            spec = self._debug_evaluate_spec(
-                name, input, job_key=debug_job_key, decision_names=decision_names
-            )
-        else:
-            spec = self._evaluate_spec(
-                name,
-                input,
-                folder_key=self._resolve_folder_key(folder_key, folder_path),
-                version=version,
-                decision_names=decision_names,
-                caller=caller,
-            )
-        response = self.request(
-            spec.method,
-            url=spec.endpoint,
-            json=spec.json,
-            headers=_headers_with_trace(spec.headers, trace_context),
-            scoped="tenant",
+        target = self._prepare_run(name, input, folder_key, folder_path)
+        spec = self._run_spec(
+            target,
+            input,
+            folder_key=self._resolve_folder_key(target),
+            version=version,
+            decision_names=decision_names,
+            caller=caller,
         )
-        return _to_run_result(_WireResponse.model_validate(response.json()))
+        # Called here, not in a helper: BaseService names the user agent after
+        # the method that calls request(), which must be the public run().
+        response = self.request(spec.method, **_request_options(spec, trace_context))
+        return _to_run_result(response.json())
 
     async def run_async(
         self,
@@ -193,34 +196,43 @@ async def run_async(
             ValueError: If the request is invalid or a required folder is missing.
             EnrichedException: If the service rejects the request.
         """
+        target = self._prepare_run(name, input, folder_key, folder_path)
+        spec = self._run_spec(
+            target,
+            input,
+            folder_key=await self._resolve_folder_key_async(target),
+            version=version,
+            decision_names=decision_names,
+            caller=caller,
+        )
+        response = await self.request_async(
+            spec.method, **_request_options(spec, trace_context)
+        )
+        return _to_run_result(response.json())
+
+    def _prepare_run(
+        self,
+        name: str,
+        input: Dict[str, Any],
+        folder_key: Optional[str],
+        folder_path: Optional[str],
+    ) -> _RunTarget:
+        """Do what run() and run_async() share before the first network call.
+
+        Decides between a debug and a deployed run, applies a binding, validates
+        the arguments and, for a deployed run, picks the folder, so only the
+        folder lookup and the request itself differ between the two.
+        """
+        # Decided on the caller's own folder arguments, before a binding swaps them.
         debug_job_key = _resolve_debug_job_key(folder_key, folder_path)
         name, folder_key, folder_path = self._apply_binding(
             name, folder_key, folder_path
         )
         _validate_run_arguments(name, input)
         if debug_job_key:
-            spec = self._debug_evaluate_spec(
-                name, input, job_key=debug_job_key, decision_names=decision_names
-            )
-        else:
-            spec = self._evaluate_spec(
-                name,
-                input,
-                folder_key=await self._resolve_folder_key_async(
-                    folder_key, folder_path
-                ),
-                version=version,
-                decision_names=decision_names,
-                caller=caller,
-            )
-        response = await self.request_async(
-            spec.method,
-            url=spec.endpoint,
-            json=spec.json,
-            headers=_headers_with_trace(spec.headers, trace_context),
-            scoped="tenant",
-        )
-        return _to_run_result(_WireResponse.model_validate(response.json()))
+            return _RunTarget(name=name, debug_job_key=debug_job_key)
+        selected_key, selected_path = self._select_folder(folder_key, folder_path)
+        return _RunTarget(name=name, folder_key=selected_key, folder_path=selected_path)
 
     @resource_override(resource_type="businessRule")
     def _overridden_resource(
@@ -273,25 +285,50 @@ def _select_folder(
             "folder_path, or set UIPATH_FOLDER_KEY or UIPATH_FOLDER_PATH"
         )
 
-    def _resolve_folder_key(
-        self, folder_key: Optional[str], folder_path: Optional[str]
-    ) -> str:
-        """Return the key of the folder the rule runs in, looking up a path."""
-        selected_key, selected_path = self._select_folder(folder_key, folder_path)
-        if selected_path:
-            selected_key = self._folders_service.retrieve_folder_key(selected_path)
-        return _require_folder_key(selected_key, selected_path)
+    def _resolve_folder_key(self, target: _RunTarget) -> Optional[str]:
+        """Return the key of the folder the rule runs in, looking up a path.
 
-    async def _resolve_folder_key_async(
-        self, folder_key: Optional[str], folder_path: Optional[str]
-    ) -> str:
+        None for a debug run, which names no folder, and for a path that
+        matches no folder, which _run_spec refuses.
+        """
+        if target.folder_path:
+            return self._folders_service.retrieve_folder_key(target.folder_path)
+        return target.folder_key
+
+    async def _resolve_folder_key_async(self, target: _RunTarget) -> Optional[str]:
         """Asynchronously return the key of the folder the rule runs in."""
-        selected_key, selected_path = self._select_folder(folder_key, folder_path)
-        if selected_path:
-            selected_key = await self._folders_service.retrieve_folder_key_async(
-                selected_path
+        if target.folder_path:
+            return await self._folders_service.retrieve_folder_key_async(
+                target.folder_path
             )
-        return _require_folder_key(selected_key, selected_path)
+        return target.folder_key
+
+    def _run_spec(
+        self,
+        target: _RunTarget,
+        input: Dict[str, Any],
+        *,
+        folder_key: Optional[str],
+        version: Optional[str] = None,
+        decision_names: Optional[List[str]] = None,
+        caller: Optional[BusinessRuleCaller] = None,
+    ) -> RequestSpec:
+        """Build the request for the endpoint the target names."""
+        if target.debug_job_key:
+            return self._debug_evaluate_spec(
+                target.name,
+                input,
+                job_key=target.debug_job_key,
+                decision_names=decision_names,
+            )
+        return self._evaluate_spec(
+            target.name,
+            input,
+            folder_key=_require_folder_key(folder_key, target.folder_path),
+            version=version,
+            decision_names=decision_names,
+            caller=caller,
+        )
 
     def _evaluate_spec(
         self,
@@ -360,6 +397,18 @@ def _resolve_debug_job_key(
     return job_key if job_key and job_key.strip() else None
 
 
+def _request_options(
+    spec: RequestSpec, trace_context: Optional[TraceContext]
+) -> Dict[str, Any]:
+    """Return the request() arguments for a spec, besides its method."""
+    return {
+        "url": spec.endpoint,
+        "json": spec.json,
+        "headers": _headers_with_trace(spec.headers, trace_context),
+        "scoped": "tenant",
+    }
+
+
 def _require_folder_key(folder_key: Optional[str], folder_path: Optional[str]) -> str:
     # A folder path that matches no folder looks up to None.
     if folder_key and folder_key.strip():
@@ -462,7 +511,8 @@ def _overall_status(
     return BusinessRuleStatus.PARTIAL_SUCCESS
 
 
-def _to_run_result(response: _WireResponse) -> BusinessRuleRunResult:
+def _to_run_result(response_body: Any) -> BusinessRuleRunResult:
+    response = _WireResponse.model_validate(response_body)
     # A successful response always carries the input's result; one without it is
     # not an answer to report as an evaluation.
     if response.result is None:

packages/uipath-platform/tests/services/test_business_rules_service.py

@@ -390,6 +390,24 @@ def test_sends_no_explain_or_batch(
         assert "explain" not in body
         assert "inputs" not in body
 
+    async def test_run_async_names_itself_in_the_user_agent(
+        self,
+        httpx_mock: HTTPXMock,
+        service: BusinessRulesService,
+        evaluate_url: str,
+        version: str,
+    ) -> None:
+        httpx_mock.add_response(url=evaluate_url, json=_response())
+
+        await service.run_async(RULE, {}, folder_key=FOLDER_KEY)
+
+        request = httpx_mock.get_request()
+        assert request is not None
+        assert (
+            request.headers[HEADER_USER_AGENT]
+            == f"UiPath.Python.Sdk/UiPath.Python.Sdk.Activities.BusinessRulesService.run_async/{version}"
+        )
+
     async def test_run_async_resolves_folder_path(
         self,
         httpx_mock: HTTPXMock,