openbox-langgraph-sdk-python 0.2.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

openbox_langgraph/__init__.py

@@ -17,6 +17,8 @@ Example:
     ... )
 """
 
+__version__ = "1.1.0"
+
 from openbox_langgraph.client import GovernanceClient, build_auth_headers
 from openbox_langgraph.config import (
     GovernanceConfig,
@@ -36,6 +38,7 @@ from openbox_langgraph.errors import (
     OpenBoxError,
     OpenBoxInsecureURLError,
     OpenBoxNetworkError,
+    OpenBoxSigningError,
 )
 from openbox_langgraph.hitl import poll_until_decision
 from openbox_langgraph.identity import (
@@ -110,11 +113,13 @@ __all__ = [
     "OpenBoxLangGraphHandler",
     "OpenBoxLangGraphHandlerOptions",
     "OpenBoxNetworkError",
+    "OpenBoxSigningError",
     "Verdict",
     "VerdictContext",
     "WorkflowEventType",
     "WorkflowSpanBuffer",
     "WorkflowSpanProcessor",
+    "__version__",
     "build_agent_identity_canonical_request",
     "build_auth_headers",
     "create_agent_identity_headers",

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

@@ -5,16 +5,28 @@ 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 OpenBoxConfigError, 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 OpenBoxConfigError as _CoreOpenBoxConfigError
+
+from openbox_langgraph.core_events import to_envelope
+from openbox_langgraph.errors import (
+    OpenBoxConfigError,
+    OpenBoxError,
+    OpenBoxNetworkError,
+    _raise_core_error,
+)
 from openbox_langgraph.identity import (
     AgentIdentityConfig,
     create_agent_identity_headers,
     parse_optional_agent_identity_config,
+    parse_optional_workload_private_key,
 )
 from openbox_langgraph.types import (
     ApprovalResponse,
@@ -25,7 +37,110 @@ from openbox_langgraph.types import (
     to_server_event_type,
 )
 
-_SDK_VERSION = "0.2.0"
+if TYPE_CHECKING:
+    from openbox_core.client import EvaluationClient
+    from openbox_core.gate import GovernanceGate
+
+_SDK_PACKAGE_VERSION = "1.1.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.
+
+    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.
+    - Base authentication, signing, and configuration errors always propagate
+      through this SDK's public errors, including under fail_open.
+    - `GovernanceAPIError` / `OpenBoxNetworkError` -> this SDK's
+      `OpenBoxNetworkError`. Bootstrap/token-exchange failures must propagate;
+      the base client applies fail_open only to ordinary governance transport errors.
+    - 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, _CoreOpenBoxConfigError) as e:
+        _raise_core_error(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(
@@ -38,13 +153,14 @@ def build_auth_headers(
 ) -> dict[str, str]:
     """Build standard auth headers for governance API calls.
 
-    Single source of truth — used by GovernanceClient and hook_governance.
+    Compatibility helper for API-key/DID requests. Workload headers are composed
+    by the base SDK after bootstrap and token exchange.
     """
     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:
@@ -87,6 +203,9 @@ class GovernanceClient:
         on_api_error: str = "fail_open",
         agent_did: str | None = None,
         agent_private_key: str | None = None,
+        gate: GovernanceGate | None = None,
+        workload_private_key: str | None = None,
+        core_client: EvaluationClient | None = None,
     ) -> None:
         self._api_url = api_url.rstrip("/")
         self._api_key = api_key
@@ -98,9 +217,43 @@ class GovernanceClient:
             did=agent_did,
             private_key=agent_private_key,
         )
+        workload_private_key = parse_optional_workload_private_key(workload_private_key)
+        self._core_client = core_client
+        self._owns_core_client = core_client is None and workload_private_key is not None
+        if self._owns_core_client:
+            from openbox_core.client import EvaluationClient
+            from openbox_core.identity import AgentIdentity
+
+            self._core_client = EvaluationClient(
+                self._api_url,
+                self._api_key,
+                timeout_seconds=timeout,
+                on_api_error=on_api_error,
+                identity=(
+                    AgentIdentity.from_private_key(
+                        self._agent_identity.did, self._agent_identity.private_key
+                    )
+                    if self._agent_identity
+                    else None
+                ),
+                workload_private_key=workload_private_key,
+                sdk_version=_SDK_PACKAGE_VERSION,
+                sdk_engine="langgraph",
+            )
+        # 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()`.
+        # The handler also lends its runtime client for sync/raw calls and
+        # approval polling, so every path shares the same workload token cache.
+        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()
 
@@ -117,7 +270,9 @@ class GovernanceClient:
         return self._sync_client
 
     async def close(self) -> None:
-        """Close the underlying HTTP clients."""
+        """Close owned HTTP clients; a borrowed runtime client belongs to its runtime."""
+        if self._owns_core_client and self._core_client is not None:
+            await self._core_client.aclose()
         if self._client and not self._client.is_closed:
             await self._client.aclose()
         self._client = None
@@ -138,6 +293,13 @@ class GovernanceClient:
         """
         from openbox_langgraph.errors import OpenBoxAuthError
 
+        if self._core_client is not None:
+            try:
+                await self._core_client.avalidate_api_key()
+            except _CoreOpenBoxConfigError as exc:
+                _raise_core_error(exc)
+            return
+
         try:
             client = self._get_client()
             response = await client.get(
@@ -186,13 +348,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(
@@ -205,18 +377,34 @@ 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:
+            try:
+                return await _gate_evaluate(self._gate, event, self._on_api_error)
+            except OpenBoxError:
+                self._forget_failed_event(event, server_event_type)
+                raise
+
+        payload = event.to_dict()
+        payload["event_type"] = server_event_type
+        payload["task_queue"] = event.task_queue or "langgraph"
+        payload["source"] = "workflow-telemetry"
+
+        if self._core_client is not None:
+            try:
+                result = await self._core_client.aevaluate(payload)
+            except (_CoreOpenBoxConfigError, _CoreGovernanceAPIError) as exc:
+                self._forget_failed_event(event, server_event_type)
+                _raise_core_error(exc)
+            return _collapse_client_synthesized_fallback(result)
+
         try:
             client = self._get_client()
             body = _json_body(payload)
@@ -231,21 +419,17 @@ class GovernanceClient:
             )
 
             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
@@ -266,6 +450,14 @@ class GovernanceClient:
         payload["task_queue"] = event.task_queue or "langgraph"
         payload["source"] = "workflow-telemetry"
 
+        if self._core_client is not None:
+            try:
+                result = self._core_client.evaluate(payload)
+            except (_CoreOpenBoxConfigError, _CoreGovernanceAPIError) as exc:
+                self._forget_failed_event(event, server_event_type)
+                _raise_core_error(exc)
+            return _collapse_client_synthesized_fallback(result)
+
         if os.environ.get("OPENBOX_DEBUG") == "1":
             import json
 
@@ -288,30 +480,36 @@ class GovernanceClient:
             )
 
             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:
         """Poll for HITL approval status.
 
-        Returns `None` on network failure so the caller can retry.
+        Returns `None` on ordinary polling transport failure so the caller can retry.
+        Workload authentication and bootstrap failures always raise.
 
         Args:
             params: Identifiers for the pending approval.
         """
+        if self._core_client is not None:
+            try:
+                result = await self._core_client.apoll_approval(
+                    params.workflow_id, params.run_id, params.activity_id
+                )
+            except _CoreOpenBoxConfigError as exc:
+                _raise_core_error(exc)
+            return ApprovalResponse.from_result(result) if result is not None else None
+
         try:
             client = self._get_client()
             body = _json_body(
@@ -335,19 +533,15 @@ class GovernanceClient:
                 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
@@ -359,8 +553,17 @@ class GovernanceClient:
         by the caller (no event_type translation needed).
 
         Args:
-            payload: The raw dict to POST to `/api/v1/governance/evaluate`.
+            payload: The raw dict to POST to the identity-appropriate evaluate route.
         """
+        if self._core_client is not None:
+            try:
+                result = await self._core_client.aevaluate(payload)
+            except (_CoreOpenBoxConfigError, _CoreGovernanceAPIError) as exc:
+                _raise_core_error(exc)
+            if _collapse_client_synthesized_fallback(result) is None:
+                return None
+            return dict(result.raw)
+
         if os.environ.get("OPENBOX_DEBUG") == "1":
             import json
 
@@ -412,6 +615,11 @@ class GovernanceClient:
     # Private helpers
     # ─────────────────────────────────────────────────────────────
 
+    def _forget_failed_event(self, event: LangChainGovernanceEvent, event_type: str) -> None:
+        """A caller retrying a rejected event must authenticate again, never dedup to ALLOW."""
+        if event.activity_id and self._dedup_run == (event.workflow_id, event.run_id):
+            self._dedup_sent.discard((event.activity_id, event_type))
+
     def _headers(self, *, method: str, pathname: str, body: bytes | str | None) -> dict[str, str]:
         return build_auth_headers(
             self._api_key,