feat(core): add get_policy_async to GovernancePolicyProvider protocol

Unblocks architecture-review §2.4 on the uipath-runtime side. The
prescription there is to hoist the policy fetch from the runtime-layer
``PolicyLoader`` (which today spins a daemon thread inside an async
runtime and blocks on ``threading.Event.wait(timeout=10s)``) up to the
async host: the CLI calls ``await provider.get_policy_async(ctx)``
itself, builds the ``PolicyIndex``, and passes the resolved index +
mode into ``GovernanceRuntime``. The runtime collapses to a pure,
synchronous-to-construct decorator — no thread, no Event, no
``is_conversational`` in the ctor.

For that to type-check on the runtime side, the structural
``GovernancePolicyProvider`` Protocol in uipath-core needs to declare
``get_policy_async``. The concrete platform provider
(``UiPathPlatformGovernanceProvider``) already implements it; the
contract was just lying about what providers expose.

Changes
- ``GovernancePolicyProvider`` now declares both ``get_policy`` and
  ``async get_policy_async``. Both required (the platform impl ships
  both today, and the doc's recommended caller path is the async
  variant — sync stays for non-event-loop callers like integration
  tests and CLI tools).
- ``_FakePolicyProvider`` in the conformance tests grew the async
  method and a separate ``async_calls`` recorder.
- New ``test_policy_round_trip_async`` exercises the async path via
  ``@pytest.mark.asyncio`` and pins that the two entry points are
  independent (calling one doesn't touch the other's recorder).

Verified
- uipath-core: ruff clean, mypy clean (45 source files), 32
  governance tests passed.
- uipath-platform: protocol-conformance tests still pass
  (9 passed) — ``UiPathPlatformGovernanceProvider`` already exposed
  ``get_policy_async``, so the now-stricter protocol still accepts it
  structurally.

No version bump — rides on the unreleased 0.5.23 that already carries
PR #1761's §1.1 (adapter-registry deletion) and §1.2 (typed
EvaluatorProtocol returns).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: viswa-uipath

packages/uipath-core/src/uipath/core/governance/providers.py

@@ -135,14 +135,34 @@ class GovernRequest(BaseModel):
 class GovernancePolicyProvider(Protocol):
     """Contract for fetching the governance policy pack.
 
-    Any object exposing a ``get_policy(context) -> PolicyResponse``
-    method satisfies this protocol.
+    Implementations expose both a sync and an async fetch. The async
+    variant is the preferred entry point for hosts running on an event
+    loop (the host can overlap policy fetch with the rest of agent
+    setup via ``asyncio.create_task`` and ``await`` the resolved
+    :class:`PolicyResponse` before constructing the governance
+    wrapper). The sync variant is kept for callers outside an event
+    loop (CLI tools, integration tests).
+
+    Any object exposing both ``get_policy(context) -> PolicyResponse``
+    and ``async def get_policy_async(context) -> PolicyResponse``
+    satisfies this protocol.
     """
 
     def get_policy(self, context: PolicyContext) -> PolicyResponse:
         """Fetch the policy pack for the active org/tenant."""
         ...
 
+    async def get_policy_async(
+        self, context: PolicyContext
+    ) -> PolicyResponse:
+        """Async variant of :meth:`get_policy`.
+
+        Hosts running on an event loop should use this so the fetch
+        doesn't block the loop and can overlap with other startup
+        work.
+        """
+        ...
+
 
 @runtime_checkable
 class GovernanceCompensationProvider(Protocol):

packages/uipath-core/tests/governance/test_providers.py

@@ -18,11 +18,16 @@
 class _FakePolicyProvider:
     def __init__(self) -> None:
         self.calls: list[PolicyContext] = []
+        self.async_calls: list[PolicyContext] = []
 
     def get_policy(self, context: PolicyContext) -> PolicyResponse:
         self.calls.append(context)
         return PolicyResponse(mode=EnforcementMode.ENFORCE, policies="rules: []")
 
+    async def get_policy_async(self, context: PolicyContext) -> PolicyResponse:
+        self.async_calls.append(context)
+        return PolicyResponse(mode=EnforcementMode.ENFORCE, policies="rules: []")
+
 
 class _FakeCompensationProvider:
     def __init__(self) -> None:
@@ -141,6 +146,24 @@ def test_policy_round_trip(self) -> None:
         assert response.mode is EnforcementMode.ENFORCE
         assert provider.calls == [PolicyContext(is_conversational=True)]
 
+    @pytest.mark.asyncio
+    async def test_policy_round_trip_async(self) -> None:
+        """The async variant is the preferred entry point for event-loop hosts.
+
+        Hosts running ``await provider.get_policy_async(ctx)`` overlap
+        the fetch with the rest of agent setup; the sync ``get_policy``
+        path remains for callers outside an event loop.
+        """
+        provider = _FakePolicyProvider()
+        response = await provider.get_policy_async(
+            PolicyContext(is_conversational=False)
+        )
+
+        assert response.mode is EnforcementMode.ENFORCE
+        assert provider.async_calls == [PolicyContext(is_conversational=False)]
+        # Sync slot stays untouched — the two entrypoints are independent.
+        assert provider.calls == []
+
     def test_compensation_round_trip(self) -> None:
         provider = _FakeCompensationProvider()
         request = _make_request()