openbox-langgraph-sdk-python 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

openbox_langgraph/__init__.py

@@ -17,6 +17,8 @@ Example:
     ... )
 """
 
+__version__ = "1.0.0"
+
 from openbox_langgraph.client import GovernanceClient, build_auth_headers
 from openbox_langgraph.config import (
     GovernanceConfig,
@@ -32,11 +34,19 @@ from openbox_langgraph.errors import (
     GovernanceHaltError,
     GuardrailsValidationError,
     OpenBoxAuthError,
+    OpenBoxConfigError,
     OpenBoxError,
     OpenBoxInsecureURLError,
     OpenBoxNetworkError,
 )
 from openbox_langgraph.hitl import poll_until_decision
+from openbox_langgraph.identity import (
+    AgentIdentityConfig,
+    build_agent_identity_canonical_request,
+    create_agent_identity_headers,
+    parse_optional_agent_identity_config,
+    validate_agent_identity_config,
+)
 from openbox_langgraph.langgraph_handler import (
     OpenBoxLangGraphHandler,
     OpenBoxLangGraphHandlerOptions,
@@ -79,6 +89,7 @@ from openbox_langgraph.verdict_handler import (
 
 __all__ = [
     "DEFAULT_HITL_CONFIG",
+    "AgentIdentityConfig",
     "ApprovalExpiredError",
     "ApprovalRejectedError",
     "ApprovalResponse",
@@ -95,6 +106,7 @@ __all__ = [
     "LangChainGovernanceEvent",
     "LangGraphStreamEvent",
     "OpenBoxAuthError",
+    "OpenBoxConfigError",
     "OpenBoxError",
     "OpenBoxInsecureURLError",
     "OpenBoxLangGraphHandler",
@@ -105,7 +117,10 @@ __all__ = [
     "WorkflowEventType",
     "WorkflowSpanBuffer",
     "WorkflowSpanProcessor",
+    "__version__",
+    "build_agent_identity_canonical_request",
     "build_auth_headers",
+    "create_agent_identity_headers",
     "create_openbox_graph_handler",
     "create_span",
     "enforce_verdict",
@@ -117,12 +132,14 @@ __all__ = [
     "merge_config",
     "parse_approval_response",
     "parse_governance_response",
+    "parse_optional_agent_identity_config",
     "poll_until_decision",
     "rfc3339_now",
     "safe_serialize",
     "setup_opentelemetry_for_governance",
     "to_server_event_type",
     "traced",
+    "validate_agent_identity_config",
     "verdict_from_string",
     "verdict_priority",
     "verdict_requires_approval",

openbox_langgraph/activity_context_binding.py

@@ -0,0 +1,126 @@
+"""Dual-write ActivityContext registration + per-turn cleanup for the opt-in
+base-SDK core runtime.
+
+`langgraph_handler.py` already registers trace/activity correlation with the
+legacy `WorkflowSpanProcessor` at every tool/LLM start and clears it at
+completion — that dual-write's counterpart lands here so the (opt-in, later
+phase) core hook runtime can resolve the SAME activity via
+`TraceContextRegistry` without the legacy processor's behavior changing by one
+line. This module is INERT unless a handler has an actual core runtime — see
+`should_dual_write`.
+
+Trace-only, never a ContextVar bind: LangGraph tool/LLM execution runs inside
+a spawned `asyncio.Task` (or, for sync tools, a `run_in_executor` worker
+thread) that already snapshot its ContextVar chain before this module's
+registration call can run — a bind here can never reach that code. See
+`core_runtime.py`'s module docstring and `tests/test_contextvars_propagation.py`
+for the empirical proof.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openbox_core.contracts.context import ActivityContext
+from openbox_core.runtime import OpenBoxRuntime
+
+from openbox_langgraph.config import GovernanceConfig
+from openbox_langgraph.core_runtime import get_trace_registry
+
+__all__ = [
+    "build_activity_context",
+    "register_activity",
+    "should_dual_write",
+    "unregister_activity",
+]
+
+
+def should_dual_write(core_runtime: OpenBoxRuntime | None) -> bool:
+    """True only when the handler owns a real core runtime.
+
+    Handlers built with an injected `client` (e.g. a test double, or a
+    subclass overriding `evaluate_event`) have `core_runtime is None` by
+    construction (`langgraph_handler.py.__init__`) — this dual-write is
+    legacy-only for them, exactly like the gate-routing it mirrors.
+    """
+    return core_runtime is not None
+
+
+def build_activity_context(
+    *,
+    config: GovernanceConfig,
+    workflow_id: str,
+    run_id: str,
+    activity_id: str,
+    activity_type: str,
+    activity_input: Any = None,
+    langgraph_node: str | None = None,
+    langgraph_step: int | None = None,
+    tool_type: str | None = None,
+    tool_name: str | None = None,
+    tool_call_id: str | None = None,
+    subagent_name: str | None = None,
+    parent_ids: list[str] | None = None,
+) -> ActivityContext:
+    """Map one LangGraph activity boundary onto the base SDK's `ActivityContext`.
+
+    `workflow_id`/`run_id` are the PER-TURN ids `langgraph_handler.py` mints in
+    `ainvoke`/`astream_governed`/`astream`/`astream_events` (NOT LangGraph's own
+    per-node `run_id`, which becomes `activity_id` instead) — matching the
+    legacy governance event's own workflow_id/run_id fields exactly, so a hook
+    resolving this context reports the same turn a dashboard operator sees
+    from the legacy path.
+    """
+    metadata: dict[str, Any] = {}
+    if langgraph_node is not None:
+        metadata["node"] = langgraph_node
+    if langgraph_step is not None:
+        metadata["step"] = langgraph_step
+    if tool_type is not None:
+        metadata["tool_type"] = tool_type
+    if tool_name is not None:
+        metadata["tool_name"] = tool_name
+    if tool_call_id is not None:
+        metadata["tool_call_id"] = tool_call_id
+    if subagent_name is not None:
+        metadata["subagent_name"] = subagent_name
+    if parent_ids:
+        metadata["parent_ids"] = list(parent_ids)
+
+    return ActivityContext(
+        workflow_id=workflow_id,
+        run_id=run_id,
+        workflow_type=config.agent_name or "LangGraphRun",
+        task_queue=config.task_queue or "langgraph",
+        activity_id=activity_id,
+        activity_type=activity_type,
+        activity_input=activity_input,
+        agent_name=config.agent_name,
+        session_id=config.session_id,
+        multi_agent_session_id=config.multi_agent_session_id,
+        metadata=metadata,
+    )
+
+
+def register_activity(
+    core_runtime: OpenBoxRuntime | None,
+    trace_id: int,
+    ctx: ActivityContext,
+) -> None:
+    """Trace-only dual-write into the runtime's private `TraceContextRegistry`.
+
+    No-op when `core_runtime` is `None` (injected-client handlers) — see
+    `should_dual_write`. Skips a zero/falsy `trace_id` the same way the legacy
+    `if trace_id:` guard at the call site already does, so a degraded OTel
+    span (no active provider) never registers a bogus all-zero correlation.
+    """
+    if core_runtime is None or not trace_id:
+        return
+    get_trace_registry(core_runtime).register(trace_id, ctx)
+
+
+def unregister_activity(core_runtime: OpenBoxRuntime | None, trace_id: int | None) -> None:
+    """Counterpart cleanup for `register_activity` — activity completion."""
+    if core_runtime is None or not trace_id:
+        return
+    get_trace_registry(core_runtime).unregister(trace_id)

openbox_langgraph/client.py

@@ -2,14 +2,26 @@
 
 from __future__ import annotations
 
+import json
 import os
 from dataclasses import dataclass
-from datetime import UTC
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import httpx
-
-from openbox_langgraph.errors import OpenBoxNetworkError
+from openbox_core.client import check_expiration
+from openbox_core.contracts.results import EvaluationResult
+from openbox_core.contracts.results import Verdict as _CoreVerdict
+from openbox_core.errors import ContractError as _CoreContractError
+from openbox_core.errors import GovernanceAPIError as _CoreGovernanceAPIError
+from openbox_core.errors import OpenBoxNetworkError as _CoreOpenBoxNetworkError
+
+from openbox_langgraph.core_events import to_envelope
+from openbox_langgraph.errors import OpenBoxConfigError, OpenBoxNetworkError
+from openbox_langgraph.identity import (
+    AgentIdentityConfig,
+    create_agent_identity_headers,
+    parse_optional_agent_identity_config,
+)
 from openbox_langgraph.types import (
     ApprovalResponse,
     GovernanceVerdictResponse,
@@ -19,20 +31,141 @@ from openbox_langgraph.types import (
     to_server_event_type,
 )
 
-_SDK_VERSION = "0.1.0"
+if TYPE_CHECKING:
+    from openbox_core.gate import GovernanceGate
+
+_SDK_PACKAGE_VERSION = "1.0.0"
+_SDK_IDENTIFIER = f"openbox-langgraph-python-v{_SDK_PACKAGE_VERSION}"
+
+
+def _network_fallback_result(on_api_error: str, msg: str) -> GovernanceVerdictResponse | None:
+    """Apply the `on_api_error` policy to a NETWORK/transport failure.
+
+    This is the ONLY place a `GovernanceClient` verdict call may return
+    `None` — it corresponds exactly to a client-synthesized fallback
+    (`EvaluationResult.fallback_allow`): `verdict=ALLOW`, `fallback_used=True`,
+    and an EMPTY `raw` dict (nothing was ever parsed from a real body).
+
+    A response BODY that happens to be `{"verdict": "block",
+    "fallback_used": true}` never reaches this function — it is parsed by
+    `_verdict_from_response_data` instead, whose `raw` is always the
+    non-empty parsed dict, so the None-collapse below can never fire for it
+    and the BLOCK is enforced normally.
+
+    `msg` is the caller's fully-formatted message (kept caller-side so the
+    two distinct failure messages — "Governance API error: HTTP {status}"
+    for a bad response, "Governance API unreachable: {e}" for a raised
+    exception — stay exactly as they were before this translation layer).
+    """
+    if on_api_error == "fail_closed":
+        raise OpenBoxNetworkError(msg)
+    result = EvaluationResult.fallback_allow(msg)
+    return _collapse_client_synthesized_fallback(result)
+
+
+def _verdict_from_response_data(data: dict[str, Any]) -> GovernanceVerdictResponse:
+    """Parse a real HTTP response body into a `GovernanceVerdictResponse`.
+
+    Routed through the base SDK's `EvaluationResult.from_dict` so `raw` is
+    always the full parsed body — the non-empty `raw` is exactly what keeps
+    `_collapse_client_synthesized_fallback` from ever mistaking a real
+    (even oddly-shaped) Core response for a client-side fallback.
+    """
+    return GovernanceVerdictResponse.from_result(EvaluationResult.from_dict(data))
+
 
+def _collapse_client_synthesized_fallback(
+    result: EvaluationResult,
+) -> GovernanceVerdictResponse | None:
+    """Return `None` ONLY for a client-synthesized fail-open fallback.
 
-def build_auth_headers(api_key: str) -> dict[str, str]:
+    The three-part discriminator matches `EvaluationResult.fallback_allow`
+    exactly and nothing else: `fallback_used=True` AND `verdict is ALLOW` AND
+    `raw` is empty (no real body was ever parsed). A response body that
+    happens to carry `fallback_used: true` alongside a blocking verdict, or
+    alongside ALLOW but WITH a real (non-empty) body, is a real Core response
+    and must be returned as a `GovernanceVerdictResponse` so callers enforce
+    it — never silently collapsed to `None`/implicit-ALLOW.
+    """
+    if result.fallback_used and result.verdict is _CoreVerdict.ALLOW and not result.raw:
+        return None
+    return GovernanceVerdictResponse.from_result(result)
+
+
+async def _gate_evaluate(
+    gate: GovernanceGate, event: LangChainGovernanceEvent, on_api_error: str
+) -> GovernanceVerdictResponse | None:
+    """Evaluate one lifecycle event through the base SDK's strict gate.
+
+    The single translation seam between `gate.aevaluate`'s base-SDK contract
+    (`EvaluationResult`, `openbox_core` exceptions) and this SDK's own
+    (`GovernanceVerdictResponse | None`, `openbox_langgraph.errors`) — every
+    gate-routed call site in `evaluate_event` goes through this function so
+    the translation is defined exactly once. Outcome policy (mirrors the legacy
+    httpx path so the wired transport is behaviourally interchangeable):
+
+    - `EvaluationResult.fallback_allow()` (client-synthesized fail-open on a
+      NETWORK error): collapsed to `None` via the same discriminator used for
+      the legacy path, so the pre-screen-`None` -> callback re-evaluation ->
+      PII-redaction flow keeps firing regardless of which transport produced it.
+    - `ContractError` (a malformed envelope — a bug in THIS SDK's own
+      event->envelope mapping, raised pre-network by the strict gate, never
+      from a Core response): ALWAYS a fail-open telemetry-drop (`None`),
+      independent of `on_api_error`. Enforcing fail_closed here would let an
+      SDK-side mapping defect block a user's graph for a reason their OWN policy
+      never produced — strictly worse than dropping one governance event.
+    - `GovernanceAPIError` / `OpenBoxNetworkError` (network-shaped failure) ->
+      this SDK's `OpenBoxNetworkError`, same public exception the legacy path
+      raises under fail_closed.
+    - Any OTHER exception (e.g. a malformed Core 200 body the base parser
+      cannot decode) is a transport-shaped fault, NOT a governance verdict:
+      routed through `_network_fallback_result` so fail_open returns `None`
+      (never crash the graph on a Core hiccup) and fail_closed raises
+      `OpenBoxNetworkError` — matching the legacy httpx catch-all exactly.
+    """
+    try:
+        result = await gate.aevaluate(to_envelope(event))
+    except _CoreContractError:
+        return None
+    except (_CoreGovernanceAPIError, _CoreOpenBoxNetworkError) as e:
+        raise OpenBoxNetworkError(str(e)) from e
+    except Exception as e:
+        return _network_fallback_result(on_api_error, f"Governance gate error: {e}")
+    return _collapse_client_synthesized_fallback(result)
+
+
+def build_auth_headers(
+    api_key: str,
+    *,
+    method: str | None = None,
+    pathname: str | None = None,
+    body: bytes | str | None = None,
+    agent_identity: AgentIdentityConfig | None = None,
+) -> dict[str, str]:
     """Build standard auth headers for governance API calls.
 
-    Single source of truth — used by GovernanceClient and hook_governance.
+    Single source of truth for the SDK's outbound governance requests.
     """
-    return {
+    headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json",
-        "User-Agent": f"OpenBox-LangGraph-SDK/{_SDK_VERSION}",
-        "X-OpenBox-SDK-Version": _SDK_VERSION,
+        "User-Agent": f"OpenBox-LangGraph-SDK/{_SDK_IDENTIFIER}",
+        "X-OpenBox-SDK-Version": _SDK_IDENTIFIER,
     }
+    if agent_identity:
+        if method is None or pathname is None:
+            msg = "method and pathname are required when signing OpenBox requests."
+            raise OpenBoxConfigError(msg)
+        headers.update(
+            create_agent_identity_headers(
+                did=agent_identity.did,
+                private_key=agent_identity.private_key,
+                method=method,
+                pathname=pathname,
+                body=body,
+            )
+        )
+    return headers
 
 
 @dataclass
@@ -58,6 +191,9 @@ class GovernanceClient:
         api_key: str,
         timeout: float = 30.0,  # seconds
         on_api_error: str = "fail_open",
+        agent_did: str | None = None,
+        agent_private_key: str | None = None,
+        gate: GovernanceGate | None = None,
     ) -> None:
         self._api_url = api_url.rstrip("/")
         self._api_key = api_key
@@ -65,10 +201,23 @@ class GovernanceClient:
         self._on_api_error = on_api_error
         self._client: httpx.AsyncClient | None = None
         self._sync_client: httpx.Client | None = None
-        self._cached_headers = build_auth_headers(api_key)
+        self._agent_identity = parse_optional_agent_identity_config(
+            did=agent_did,
+            private_key=agent_private_key,
+        )
+        # Optional base-SDK gate. When wired (by the handler, from a core
+        # runtime built off the SAME api_url/api_key/timeout/on_api_error),
+        # `evaluate_event`'s ASYNC path routes lifecycle events through it
+        # instead of this client's own httpx transport — see `evaluate_event`.
+        # `None` (the default) preserves the exact legacy transport/serialization
+        # for every existing caller that constructs a bare `GovernanceClient()`.
+        # `evaluate_event_sync` (sync middleware hooks) is unaffected either way.
+        self._gate = gate
         # Deduplication: prevent sending the same (activity_id, event_type) twice
         # within the same workflow run. Keyed by (workflow_id, run_id) so it resets
-        # automatically on each new ainvoke() call.
+        # automatically on each new ainvoke() call. Shared by every evaluate_event
+        # call site regardless of which transport (gate or legacy httpx) is active
+        # for a given call — dedup is a client-level concern, not a transport one.
         self._dedup_run: tuple[str, str] | None = None
         self._dedup_sent: set[tuple[str, str]] = set()
 
@@ -110,7 +259,11 @@ class GovernanceClient:
             client = self._get_client()
             response = await client.get(
                 f"{self._api_url}/api/v1/auth/validate",
-                headers=self._headers(),
+                headers=self._headers(
+                    method="GET",
+                    pathname="/api/v1/auth/validate",
+                    body=b"",
+                ),
             )
             if response.status_code in (401, 403):
                 msg = "Invalid API key. Check your API key at dashboard.openbox.ai"
@@ -150,13 +303,23 @@ class GovernanceClient:
         """Send a governance event to OpenBox Core and return the verdict.
 
         Returns `None` on network failure when `on_api_error` is `fail_open`.
-        Silently drops duplicate (activity_id, event_type) pairs within the same run.
+        Silently drops duplicate (activity_id, event_type) pairs within the same run
+        — this de-dup pre-check runs BEFORE either transport below, so it applies
+        identically whether a `gate` is wired or not.
+
+        When a `gate` was supplied at construction (see `__init__`), the event is
+        routed through the base SDK's `EventEnvelope` + `GovernanceGate.aevaluate`
+        instead of this client's own httpx transport — see `_gate_evaluate`.
+        Overriding `evaluate_event` in a subclass (e.g. the golden-fixture
+        harness's `RecordingGovernanceClient`) still fully intercepts either way,
+        since the branch lives inside THIS method, never at a call site.
 
         Args:
             event: The governance event payload to evaluate.
 
         Raises:
-            OpenBoxNetworkError: On network failure when `on_api_error` is `fail_closed`.
+            OpenBoxNetworkError: On network failure when `on_api_error` is `fail_closed`
+                (from either transport).
         """
         server_event_type = to_server_event_type(event.event_type)
         if event.activity_id and self._is_duplicate(
@@ -169,41 +332,49 @@ class GovernanceClient:
                 )
             return None
 
-        payload = event.to_dict()
-        payload["event_type"] = server_event_type
-        payload["task_queue"] = event.task_queue or "langgraph"
-        payload["source"] = "workflow-telemetry"
-
         if os.environ.get("OPENBOX_DEBUG") == "1":
             import json
+
             print(
-                f"[OpenBox Debug] governance request: {json.dumps(payload, indent=2, default=str)}"
+                f"[OpenBox Debug] governance request: "
+                f"{json.dumps(event.to_dict(), indent=2, default=str)}"
             )
 
+        if self._gate is not None:
+            return await _gate_evaluate(self._gate, event, self._on_api_error)
+
+        payload = event.to_dict()
+        payload["event_type"] = server_event_type
+        payload["task_queue"] = event.task_queue or "langgraph"
+        payload["source"] = "workflow-telemetry"
+
         try:
             client = self._get_client()
+            body = _json_body(payload)
             response = await client.post(
                 f"{self._api_url}/api/v1/governance/evaluate",
-                headers=self._headers(),
-                json=payload,
+                headers=self._headers(
+                    method="POST",
+                    pathname="/api/v1/governance/evaluate",
+                    body=body,
+                ),
+                content=body,
             )
 
             if not response.is_success:
-                if self._on_api_error == "fail_closed":
-                    msg = f"Governance API error: HTTP {response.status_code}"
-                    raise OpenBoxNetworkError(msg)
-                return None
+                return _network_fallback_result(
+                    self._on_api_error, f"Governance API error: HTTP {response.status_code}"
+                )
 
             data = response.json()
-            return GovernanceVerdictResponse.from_dict(data)
+            return _verdict_from_response_data(data)
 
         except OpenBoxNetworkError:
             raise
         except Exception as e:
-            if self._on_api_error == "fail_closed":
-                msg = f"Governance API unreachable: {e}"
-                raise OpenBoxNetworkError(msg) from e
-            return None
+            return _network_fallback_result(
+                self._on_api_error, f"Governance API unreachable: {e}"
+            )
 
     def evaluate_event_sync(
         self, event: LangChainGovernanceEvent
@@ -226,6 +397,7 @@ class GovernanceClient:
 
         if os.environ.get("OPENBOX_DEBUG") == "1":
             import json
+
             print(
                 "[OpenBox Debug] sync governance request:"
                 f" {json.dumps(payload, indent=2, default=str)}"
@@ -233,32 +405,33 @@ class GovernanceClient:
 
         try:
             client = self._get_sync_client()
+            body = _json_body(payload)
             response = client.post(
                 f"{self._api_url}/api/v1/governance/evaluate",
-                headers=self._headers(),
-                json=payload,
+                headers=self._headers(
+                    method="POST",
+                    pathname="/api/v1/governance/evaluate",
+                    body=body,
+                ),
+                content=body,
             )
 
             if not response.is_success:
-                if self._on_api_error == "fail_closed":
-                    msg = f"Governance API error: HTTP {response.status_code}"
-                    raise OpenBoxNetworkError(msg)
-                return None
+                return _network_fallback_result(
+                    self._on_api_error, f"Governance API error: HTTP {response.status_code}"
+                )
 
             data = response.json()
-            return GovernanceVerdictResponse.from_dict(data)
+            return _verdict_from_response_data(data)
 
         except OpenBoxNetworkError:
             raise
         except Exception as e:
-            if self._on_api_error == "fail_closed":
-                msg = f"Governance API unreachable: {e}"
-                raise OpenBoxNetworkError(msg) from e
-            return None
+            return _network_fallback_result(
+                self._on_api_error, f"Governance API unreachable: {e}"
+            )
 
-    async def poll_approval(
-        self, params: ApprovalPollParams
-    ) -> ApprovalResponse | None:
+    async def poll_approval(self, params: ApprovalPollParams) -> ApprovalResponse | None:
         """Poll for HITL approval status.
 
         Returns `None` on network failure so the caller can retry.
@@ -268,39 +441,41 @@ class GovernanceClient:
         """
         try:
             client = self._get_client()
-            response = await client.post(
-                f"{self._api_url}/api/v1/governance/approval",
-                headers=self._headers(),
-                json={
+            body = _json_body(
+                {
                     "workflow_id": params.workflow_id,
                     "run_id": params.run_id,
                     "activity_id": params.activity_id,
-                },
+                }
+            )
+            response = await client.post(
+                f"{self._api_url}/api/v1/governance/approval",
+                headers=self._headers(
+                    method="POST",
+                    pathname="/api/v1/governance/approval",
+                    body=body,
+                ),
+                content=body,
             )
 
             if not response.is_success:
                 return None
 
             data = response.json()
-            parsed = parse_approval_response(data)
-
-            # SDK-side expiration check
-            if parsed.approval_expiration_time and not parsed.expired:
-                from datetime import datetime
-                expiry = datetime.fromisoformat(
-                    parsed.approval_expiration_time.replace("Z", "+00:00")
-                )
-                if expiry < datetime.now(tz=UTC):
-                    parsed.expired = True
-
-            return parsed
+            # SDK-side expiration check — run on the raw dict BEFORE parsing
+            # (matches openbox_core.client.check_expiration's own call order:
+            # check_expiration(data) then ApprovalResult.from_dict(data)).
+            # Handles ISO 'Z', ISO offset, and space-separated DB timestamp
+            # formats; a malformed timestamp is logged and left un-flagged
+            # rather than raised, so one bad timestamp string degrades to
+            # "expiration not confirmed" instead of aborting the whole poll.
+            check_expiration(data)
+            return parse_approval_response(data)
 
         except Exception:
             return None
 
-    async def evaluate_raw(
-        self, payload: dict[str, Any]
-    ) -> dict[str, Any] | None:
+    async def evaluate_raw(self, payload: dict[str, Any]) -> dict[str, Any] | None:
         """Send a pre-built payload to the governance evaluate endpoint.
 
         Used by hook-level governance where the payload is fully assembled
@@ -311,16 +486,22 @@ class GovernanceClient:
         """
         if os.environ.get("OPENBOX_DEBUG") == "1":
             import json
+
             print(
                 f"[OpenBox Debug] span hook request: {json.dumps(payload, indent=2, default=str)}"
             )
 
         try:
             client = self._get_client()
+            body = _json_body(payload)
             response = await client.post(
                 f"{self._api_url}/api/v1/governance/evaluate",
-                headers=self._headers(),
-                json=payload,
+                headers=self._headers(
+                    method="POST",
+                    pathname="/api/v1/governance/evaluate",
+                    body=body,
+                ),
+                content=body,
             )
 
             if not response.is_success:
@@ -354,5 +535,15 @@ class GovernanceClient:
     # Private helpers
     # ─────────────────────────────────────────────────────────────
 
-    def _headers(self) -> dict[str, str]:
-        return self._cached_headers
+    def _headers(self, *, method: str, pathname: str, body: bytes | str | None) -> dict[str, str]:
+        return build_auth_headers(
+            self._api_key,
+            method=method,
+            pathname=pathname,
+            body=body,
+            agent_identity=self._agent_identity,
+        )
+
+
+def _json_body(payload: dict[str, Any]) -> bytes:
+    return json.dumps(payload, separators=(",", ":"), default=str).encode("utf-8")