chore(governance): apply review feedback (no import-time registration, framework-only can_handle)

Mirror radu's LangChain-adapter review across the LlamaIndex adapter:
- __init__: drop the import-time registration side-effect; registration only via the uipath.governance.adapters entry point.
- can_handle: claim only a real workflows.Workflow; remove the duck-typed (run / Workflow-shaped name) fallback.
- docstring: 'governance host' instead of uipath-runtime internals.
- tests: can_handle uses a real stepped Workflow; a duck-typed look-alike is now rejected.

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

Author: aditik0303

packages/uipath-llamaindex/src/uipath_llamaindex/governance/__init__.py

@@ -1,19 +1,17 @@
 """Governance integration for ``uipath-llamaindex``.
 
-Registers :class:`LlamaIndexAdapter` with the global adapter registry in
-``uipath.core.adapters`` so ``uipath.runtime.governance.GovernanceRuntime`` can
-attach the LlamaIndex-specific governance (BEFORE_MODEL, AFTER_MODEL, TOOL_CALL)
-when it sees a LlamaIndex workflow/agent.
+Registers :class:`LlamaIndexAdapter` with the adapter registry in
+``uipath.core.adapters`` so the governance host can attach the
+LlamaIndex-specific governance (BEFORE_MODEL, AFTER_MODEL, TOOL_CALL) when it
+sees a LlamaIndex workflow/agent.
 
 Registration is **idempotent**: calling :func:`register_governance_adapter`
 twice is a no-op on the second call.
 
-Wiring:
-    1. Importing this module triggers registration as a side-effect, so any
-       caller that does ``import uipath_llamaindex.governance`` is opted in.
-    2. The package also exposes :func:`register_governance_adapter` as an entry
-       point under ``uipath.governance.adapters`` so the registry's entry-point
-       discovery can plug us in without an explicit import.
+Wiring: the package exposes :func:`register_governance_adapter` as an entry
+point under ``uipath.governance.adapters``. The governance adapter discovery
+path calls it to register the adapter. Importing this module does not, by
+itself, mutate the global registry.
 """
 
 from __future__ import annotations
@@ -46,9 +44,6 @@ def register_governance_adapter() -> None:
     logger.debug("Registered uipath-llamaindex governance adapter")
 
 
-# Side-effect registration on module import.
-register_governance_adapter()
-
 
 __all__ = [
     "GovernanceEventHandler",

packages/uipath-llamaindex/src/uipath_llamaindex/governance/adapter.py

@@ -22,8 +22,8 @@
 where it is fed back to the model as input (analogous to how the OpenAI adapter
 handles its missing tool-args).
 
-Chain-level boundaries (BEFORE_AGENT / AFTER_AGENT) are owned by the runtime
-wrapper layer in ``uipath-runtime`` and are intentionally not fired here.
+Chain-level boundaries (BEFORE_AGENT / AFTER_AGENT) are owned by the
+governance host and are intentionally not fired here.
 
 Contracts and the evaluator protocol come from ``uipath-core``; this package
 contributes only the LlamaIndex-specific implementation and self-registers it
@@ -43,8 +43,8 @@
 from typing import Any, Dict, List
 from uuid import uuid4
 
-from llama_index.core.instrumentation import (
-    get_dispatcher,  # type: ignore[attr-defined]
+from llama_index.core.instrumentation import (  # type: ignore[attr-defined]
+    get_dispatcher,
 )
 from llama_index.core.instrumentation.event_handlers.base import (  # type: ignore[attr-defined]
     BaseEventHandler,
@@ -77,24 +77,12 @@ def name(self) -> str:
         return "LlamaIndex"
 
     def can_handle(self, agent: Any) -> bool:
-        """Return True if this looks like a LlamaIndex workflow/agent."""
+        """Return True only for a LlamaIndex ``Workflow`` (incl. agent workflows)."""
         try:
             from workflows import Workflow
-
-            if isinstance(agent, Workflow):
-                return True
         except ImportError:
-            pass
-
-        # Duck-typed fallback: a workflow/agent exposes ``run`` and a workflow
-        # step surface (``_get_steps`` / ``steps``) or a Workflow-shaped name.
-        if hasattr(agent, "run") and (
-            hasattr(agent, "_get_steps")
-            or hasattr(agent, "steps")
-            or type(agent).__name__.endswith(("Workflow", "Agent"))
-        ):
-            return True
-        return False
+            return False
+        return isinstance(agent, Workflow)
 
     def attach(
         self,

packages/uipath-llamaindex/tests/governance/test_adapter.py

@@ -87,11 +87,22 @@ def _handler(ev: FakeEvaluator) -> GovernanceEventHandler:
 # --------------------------------------------------------------------------
 
 
-def test_can_handle_workflow_like():
-    assert LlamaIndexAdapter().can_handle(FakeWorkflow()) is True
+def test_can_handle_real_workflow():
+    from workflows import Workflow, step
+    from workflows.events import StartEvent, StopEvent
 
+    class _RealWorkflow(Workflow):
+        @step
+        async def go(self, ev: StartEvent) -> StopEvent:
+            return StopEvent()
 
-def test_can_handle_rejects_plain_object():
+    assert LlamaIndexAdapter().can_handle(_RealWorkflow()) is True
+
+
+def test_can_handle_rejects_non_workflow():
+    # A duck-typed look-alike (has run / Workflow-shaped name) must NOT be
+    # claimed — only a real workflows.Workflow is.
+    assert LlamaIndexAdapter().can_handle(FakeWorkflow()) is False
     assert LlamaIndexAdapter().can_handle(object()) is False