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

openbox_langgraph/__init__.py

@@ -17,7 +17,7 @@ Example:
     ... )
 """
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 from openbox_langgraph.client import GovernanceClient, build_auth_headers
 from openbox_langgraph.config import (

openbox_langgraph/activity_approval.py

@@ -0,0 +1,156 @@
+"""Wait at the governed operation, preserving its stack and activity identity."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from dataclasses import dataclass, field
+
+from openbox_core.client import EvaluationClient
+from openbox_core.contracts.context import ActivityContext
+from openbox_core.contracts.results import ApprovalResult, EvaluationResult, Verdict
+
+from openbox_langgraph.errors import (
+    ApprovalExpiredError,
+    ApprovalRejectedError,
+    OpenBoxConfigError,
+    _raise_core_error,
+)
+from openbox_langgraph.types import HITLConfig
+
+
+@dataclass
+class _ApprovalTurn:
+    cancelled: threading.Event = field(default_factory=threading.Event)
+    decisions: dict[
+        str, tuple[EvaluationResult, ApprovalExpiredError | ApprovalRejectedError | None]
+    ] = field(default_factory=dict)
+
+
+class ActivityApprovalWaiter:
+    """Share approval decisions between the sync and async tool callbacks.
+
+    The callbacks can enforce the same stashed evaluation twice. Only that
+    exact evaluation is reusable: a later hook verdict on the same activity
+    must get its own decision. All state is discarded when the turn ends.
+    """
+
+    def __init__(self, client: EvaluationClient, config: HITLConfig) -> None:
+        self._client = client
+        self._config = config
+        self._lock = threading.Lock()
+        self._turns: dict[tuple[str, str], _ApprovalTurn] = {}
+
+    def begin_turn(self, workflow_id: str, run_id: str) -> None:
+        with self._lock:
+            self._turns[(workflow_id, run_id)] = _ApprovalTurn()
+
+    def end_turn(self, workflow_id: str) -> None:
+        with self._lock:
+            for key in list(self._turns):
+                if key[0] == workflow_id:
+                    self._turns.pop(key).cancelled.set()
+
+    def _turn(self, ctx: ActivityContext) -> _ApprovalTurn:
+        workflow_id, run_id, _ = self._identity(ctx)
+        with self._lock:
+            turn = self._turns.get((workflow_id, run_id))
+        if turn is None:
+            raise OpenBoxConfigError("Approval requires an active governed turn")
+        return turn
+
+    @staticmethod
+    def _identity(ctx: ActivityContext) -> tuple[str, str, str]:
+        if not ctx.workflow_id or not ctx.run_id or not ctx.activity_id:
+            raise OpenBoxConfigError("Approval requires workflow, run, and activity IDs")
+        return ctx.workflow_id, ctx.run_id, ctx.activity_id
+
+    @staticmethod
+    def _check_cancelled(turn: _ApprovalTurn) -> None:
+        # Cancelling an asyncio task does not stop its executor thread. Wake
+        # the sync waiter too, so a late approval cannot run an abandoned tool.
+        if turn.cancelled.is_set():
+            raise asyncio.CancelledError
+
+    def _reuse_decision(
+        self, turn: _ApprovalTurn, ctx: ActivityContext, result: EvaluationResult
+    ) -> bool:
+        self._check_cancelled(turn)
+        with self._lock:
+            decision = turn.decisions.get(self._identity(ctx)[2])
+        if decision is None or decision[0] is not result:
+            return False
+        if decision[1] is not None:
+            raise decision[1]
+        return True
+
+    def _record_response(
+        self,
+        turn: _ApprovalTurn,
+        ctx: ActivityContext,
+        result: EvaluationResult,
+        response: ApprovalResult | None,
+    ) -> bool:
+        self._check_cancelled(turn)
+        try:
+            approved = self._approved(response, ctx)
+        except (ApprovalExpiredError, ApprovalRejectedError) as exc:
+            with self._lock:
+                turn.decisions[self._identity(ctx)[2]] = (result, exc)
+            raise
+        if not approved:
+            return False
+        with self._lock:
+            turn.decisions[self._identity(ctx)[2]] = (result, None)
+        return True
+
+    @staticmethod
+    def _approved(response: ApprovalResult | None, ctx: ActivityContext) -> bool:
+        if response is None:
+            return False
+        if response.expired:
+            raise ApprovalExpiredError(f"Approval expired for {ctx.activity_type}")
+        if response.verdict in (Verdict.BLOCK, Verdict.HALT):
+            raise ApprovalRejectedError(
+                response.reason or f"Approval rejected for {ctx.activity_type}"
+            )
+        return response.verdict is Verdict.ALLOW
+
+    async def wait(self, result: EvaluationResult, ctx: ActivityContext) -> None:
+        turn = self._turn(ctx)
+        if self._reuse_decision(turn, ctx, result):
+            return
+        while True:
+            self._check_cancelled(turn)
+            try:
+                response = await self._client.apoll_approval(*self._identity(ctx))
+            except Exception as exc:
+                _raise_core_error(exc)
+            self._check_cancelled(turn)
+            if self._record_response(turn, ctx, result, response):
+                return
+            await asyncio.sleep(self._config.poll_interval_ms / 1000.0)
+
+    def wait_sync(self, result: EvaluationResult, ctx: ActivityContext) -> None:
+        turn = self._turn(ctx)
+        if self._reuse_decision(turn, ctx, result):
+            return
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass  # A sync tool runs in LangChain's executor thread.
+        else:
+            raise OpenBoxConfigError(
+                "A synchronous operation requiring approval cannot wait on the event-loop "
+                "thread. Use its async API or run it with asyncio.to_thread()."
+            )
+        while True:
+            self._check_cancelled(turn)
+            try:
+                response = self._client.poll_approval(*self._identity(ctx))
+            except Exception as exc:
+                _raise_core_error(exc)
+            self._check_cancelled(turn)
+            if self._record_response(turn, ctx, result, response):
+                return
+            turn.cancelled.wait(self._config.poll_interval_ms / 1000.0)

openbox_langgraph/client.py

@@ -41,7 +41,7 @@ if TYPE_CHECKING:
     from openbox_core.client import EvaluationClient
     from openbox_core.gate import GovernanceGate
 
-_SDK_PACKAGE_VERSION = "1.1.0"
+_SDK_PACKAGE_VERSION = "1.2.0"
 _SDK_IDENTIFIER = f"openbox-langgraph-python-v{_SDK_PACKAGE_VERSION}"
 
 

openbox_langgraph/core_adapter.py

@@ -1,24 +1,8 @@
 # openbox_langgraph/core_adapter.py
-"""LangGraph ``FrameworkAdapter`` for the opt-in ``openbox_core`` hook runtime.
-
-Maps base-SDK governance verdicts onto the LangGraph-native error types
-(``openbox_langgraph.errors.GovernanceBlockedError``/``GovernanceHaltError``)
-the handler's existing ``ainvoke``/``astream_governed`` catch blocks already
-understand — no new error vocabulary, no new control flow at the call site.
-
-RAISE-ONLY approval, mirroring the legacy hook path exactly: an inline
-blocking poller on the event-loop thread (``time.sleep`` in
-``ApprovalPoller.wait_for_decision``) would freeze every other coroutine on
-that loop — LangGraph tools/LLM calls run as concurrent ``asyncio.Task``s, so
-blocking the loop thread blocks ALL of them, not just the approval-pending
-one. The handler's OUTER catch/poll/retry in ``ainvoke``/``_pre_screen_input``
-is the single HITL driver today (catches ``GovernanceBlockedError`` with
-``verdict == "require_approval"``, awaits ``poll_until_decision``, retries);
-this adapter reproduces that same shape for hook-level (started-stage
-HTTP/DB/file/function) verdicts so the SAME outer loop drives them too.
-Defining ``handle_approval_sync`` here also pre-empts
-``openbox_core.hooks.preflight.HookRuntime._sync_approval``'s fallback to its
-own inline ``ApprovalPoller`` (adapter-native flow always wins when present).
+"""Map base-SDK verdicts to native errors and wait at pending operations.
+
+A handler configures an activity waiter for each governed turn. Standalone
+adapters without a waiter still raise REQUIRE_APPROVAL to fail closed.
 """
 
 from __future__ import annotations
@@ -29,6 +13,7 @@ from openbox_core.context import ContextStore
 from openbox_core.contracts.context import ActivityContext
 from openbox_core.contracts.results import EvaluationResult, Verdict
 
+from openbox_langgraph.activity_approval import ActivityApprovalWaiter
 from openbox_langgraph.errors import GovernanceBlockedError, GovernanceHaltError
 
 __all__ = ["LangGraphFrameworkAdapter"]
@@ -53,6 +38,7 @@ class LangGraphFrameworkAdapter:
         context_store: ContextStore | None = None,
     ) -> None:
         self._store = context_store if context_store is not None else ContextStore()
+        self.approval_waiter: ActivityApprovalWaiter | None = None
 
     # ── Lifecycle verdicts (WorkflowStarted/LLMStarted pre-screen, etc.) ───
 
@@ -90,43 +76,33 @@ class LangGraphFrameworkAdapter:
         reason = result.reason or "Blocked by governance"
         raise GovernanceBlockedError(result.verdict.value, reason, identifier)
 
-    # ── Approval (RAISE-ONLY — never an inline blocking wait) ──────────────
+    # ── Approval: resume the same operation after its decision ────────────
 
     async def handle_approval(
         self, result: EvaluationResult, context: ActivityContext | None = None
     ) -> None:
-        """Async started-hook REQUIRE_APPROVAL -> raise, never await inline.
-
-        The base ``HookRuntime._adecide_started`` treats a normal RETURN as
-        "approved, proceed" — raising here is the correct "not approved yet"
-        signal for a ``requires_approval()`` verdict, so the handler's outer
-        catch/poll/retry loop drives the approval flow.
-        """
+        """Suspend this coroutine without unwinding the graph or blocking the loop."""
         ctx = context if context is not None else self._store.current_activity_context()
-        self._raise_pending_approval(result, ctx)
+        if self.approval_waiter is None or ctx is None:
+            self._raise_pending_approval(result, ctx)
+        try:
+            await self.approval_waiter.wait(result, ctx)
+        except Exception:
+            self._store.mark_activity_aborted(ctx.workflow_id, ctx.activity_id)
+            raise
 
     def handle_approval_sync(
         self, result: EvaluationResult, *, context: ActivityContext | None = None
     ) -> None:
-        """Sync started-hook REQUIRE_APPROVAL -> raise, never poll inline.
-
-        ``context`` is the span-resolved ``ActivityContext``
-        ``HookRuntime._sync_approval`` passes explicitly — it can differ from
-        the ambient ``ContextStore.current_activity_context()`` (e.g. a sync
-        tool running inside ``run_in_executor``, where the ContextVar bound on
-        the async stream-consumer never reached the worker thread). Preferring
-        the passed context over the ambient lookup keeps the abort-mark keyed
-        on the SAME workflow/activity id the operation is actually running
-        under.
-
-        Defining this method is what stops
-        ``HookRuntime._sync_approval`` from falling back to its own inline
-        ``ApprovalPoller.wait_for_decision`` (a blocking ``time.sleep`` loop on
-        whatever thread called this) — an adapter-native
-        ``handle_approval_sync`` always takes priority when present.
-        """
+        """Suspend the sync tool's worker thread, preserving its current stack."""
         ctx = context if context is not None else self._store.current_activity_context()
-        self._raise_pending_approval(result, ctx)
+        if self.approval_waiter is None or ctx is None:
+            self._raise_pending_approval(result, ctx)
+        try:
+            self.approval_waiter.wait_sync(result, ctx)
+        except Exception:
+            self._store.mark_activity_aborted(ctx.workflow_id, ctx.activity_id)
+            raise
 
     def _raise_pending_approval(
         self, result: EvaluationResult, ctx: ActivityContext | None
@@ -151,36 +127,12 @@ class LangGraphFrameworkAdapter:
         adapter's ``on_completed_hook_result``, which is also a no-op)."""
         return None
 
-    # ── Post-approval reset (clears the base store before the retry) ───────
+    # ── Compatibility helper for callers managing abort marks themselves ──
 
     def reset_after_approval(self, workflow_id: str | None) -> None:
-        """Clear every abort mark registered under ``workflow_id`` on the base
-        store, so the caller's retry (already GRANTED by
-        ``poll_until_decision``) runs GOVERNED instead of short-circuiting on
-        a stale abort flag from the blocked first pass.
-
-        Scoped to ``workflow_id`` (the per-TURN id), not a single
-        ``activity_id``: an approved retry re-invokes the underlying graph
-        directly (bypassing this SDK's own registration), so the exact
-        ``activity_id`` its operations will use is not knowable up front — but
-        every activity a hook could have aborted THIS turn shares the SAME
-        ``workflow_id``. See ``TraceContextRegistry.clear_aborted_for_workflow``
-        for why the store needed a new, narrower-than-``sweep`` method for this
-        (``sweep`` also drops trace state the retry still needs).
-
-        Call this AFTER ``poll_until_decision`` resolves and BEFORE
-        re-invoking the graph — never before the poll (that would let a
-        second concurrent hook evaluation ignore the still-pending approval).
-
-        Clears the base store — via the ``TraceContextRegistry`` published on
-        the store as ``store.registry`` (``create_core_runtime`` sets it to the
-        runtime's registry; duck-typed by attribute, not import, to avoid a
-        circular import), which sweeps every activity key registered this turn.
-        Falls back to a direct ``clear_activity_aborted`` on the ambient bound
-        context when no registry is published (a store built outside
-        ``create_core_runtime``).
-
-        No-op when ``workflow_id`` is falsy (nothing is ever keyed on it).
+        """Clear a workflow's abort marks for legacy callers.
+
+        Normal governed turns wait in place and do not use this helper.
         """
         if not workflow_id:
             return

openbox_langgraph/core_runtime.py

@@ -54,7 +54,7 @@ from openbox_langgraph.trace_context_registry import (
 CORE_ENV_PREFIX = "OPENBOX_LANGGRAPH"
 SDK_ENGINE = "langgraph"
 SDK_LANGUAGE = "python"
-SDK_PACKAGE_VERSION = "1.1.0"
+SDK_PACKAGE_VERSION = "1.2.0"
 
 __all__ = [
     "CORE_ENV_PREFIX",

openbox_langgraph/langgraph_handler.py

@@ -30,6 +30,7 @@ from openbox_langchain.activity_bridge import EventType
 from opentelemetry import context as otel_context
 from opentelemetry import trace as otel_trace
 
+from openbox_langgraph.activity_approval import ActivityApprovalWaiter
 from openbox_langgraph.activity_context_binding import (
     build_activity_context,
     register_activity,
@@ -38,6 +39,7 @@ from openbox_langgraph.activity_context_binding import (
 )
 from openbox_langgraph.client import GovernanceClient
 from openbox_langgraph.config import get_global_config, merge_config
+from openbox_langgraph.core_adapter import LangGraphFrameworkAdapter
 from openbox_langgraph.core_runtime import create_core_runtime, get_trace_registry
 from openbox_langgraph.errors import (
     ApprovalExpiredError,
@@ -67,53 +69,6 @@ _logger = logging.getLogger(__name__)
 _otel_tracer = otel_trace.get_tracer("openbox-langgraph")
 
 
-def _extract_governance_blocked(exc: Exception) -> GovernanceBlockedError | None:
-    """Walk exception chain to find a wrapped GovernanceBlockedError.
-
-    LLM SDKs (OpenAI, Anthropic) wrap httpx errors. When an OTel hook raises
-    GovernanceBlockedError inside httpx, the LLM SDK wraps it as APIConnectionError.
-    This function unwraps the chain via __cause__ / __context__ to recover it.
-    """
-    cause: BaseException | None = exc
-    seen: set[int] = set()
-    while cause is not None:
-        if id(cause) in seen:
-            break
-        seen.add(id(cause))
-        if isinstance(cause, GovernanceBlockedError):
-            return cause
-        cause = getattr(cause, '__cause__', None) or getattr(cause, '__context__', None)
-    return None
-
-
-def _approval_poll_activity_id(hook_err: GovernanceBlockedError, run_id: str) -> str:
-    """Resolve the activity id `ainvoke`'s outer HITL poll should use (C5).
-
-    Core matches a pending approval on `(workflow_id, run_id, activity_id)`
-    exactly (`GovernanceClient.poll_approval` / `ApprovalPollParams` — no
-    other identifying field travels in that request), so polling the WRONG
-    activity_id never resolves and `poll_until_decision`'s unbounded `while
-    True` loop hangs forever.
-
-    A REQUIRE_APPROVAL raised by the pure-LangChain-Core tool callback
-    (installed under the C1 condition) carries the tool's REAL activity_id in
-    `.identifier` — set by `LangGraphFrameworkAdapter._raise_pending_approval`
-    from `current_activity_context()`, which resolves correctly here because
-    `run_inline=True` means the callback raises INSIDE the ToolNode's
-    `activity_scope(ctx, store=store)` (see `tool_activity_binding.py`). Use
-    it verbatim so the poll targets the SAME row the tool's ActivityStarted
-    opened — mirroring the pre-existing tool_start/tool_end HITL poll in
-    `_process_event`, which has always polled the tool's own activity_id
-    rather than a synthetic hook id.
-
-    Falls back to the legacy synthetic `f"{run_id}-hook"` id when no
-    identifier is carried (the base-hook — HTTP/DB/file/function preflight —
-    REQUIRE_APPROVAL path this `except` block already handled before this
-    phase; those raises carry no tool activity_id and are unaffected).
-    """
-    return hook_err.identifier or f"{run_id}-hook"
-
-
 # ═══════════════════════════════════════════════════════════════════
 # Run buffer (tracks in-flight runs for duration/context)
 # ═══════════════════════════════════════════════════════════════════
@@ -360,6 +315,7 @@ class OpenBoxLangGraphHandler:
         # below. `None` here means "no callback, no bridge, consumer governs
         # every tool event unconditionally", matching today's behavior exactly.
         self._activity_bridge: ActivityBridge | None = None
+        self._activity_approvals: ActivityApprovalWaiter | None = None
 
         if opts.client:
             # Injected client (e.g. a test double, or a subclass overriding
@@ -607,9 +563,8 @@ class OpenBoxLangGraphHandler:
         No-op when the handler has no core runtime (`_core_runtime is None` —
         injected-client handlers, legacy-only). Every public entry point calls
         this from the OUTERMOST `finally` of its stream loop so it runs
-        exactly once per turn regardless of success, mid-stream exception, or
-        (for `ainvoke`) an approved hook-approval retry — see the `finally`
-        placement in each entry point for why ordering after the retry matters.
+        exactly once per turn regardless of success, mid-stream exception,
+        approval rejection, or cancellation while waiting for approval.
         Stays SYNCHRONOUS (existing tests spy/patch it with a plain callable
         called without `await`) — the C6 orphan-close below uses the base
         SDK's SYNC gate for the same reason.
@@ -635,18 +590,12 @@ class OpenBoxLangGraphHandler:
         above never sees that key) — clear those directly on the runtime's
         store so they cannot leak for the handler's lifetime.
 
-        The abort-mark clear runs UNCONDITIONALLY for every swept tool record
-        (not gated on `record.abort_marked`): a REQUIRE_APPROVAL raised by the
-        callback can propagate through ANY entry point (`ainvoke` polls and
-        retries it; `astream_governed`/`astream`/`astream_events` have no
-        catch/poll loop at all — pre-existing, HITL retry is `ainvoke`-only —
-        and simply propagate it to the caller), so a per-entry-point catch
-        site is not a reliable place to set the flag. `clear_activity_aborted`
-        is an idempotent set-discard — a no-op for a record that was never
-        actually aborted — so clearing unconditionally is always safe.
-        `record.abort_marked` is still set (see `_mark_bridge_abort`) and
-        checked here as a fast-path/diagnostic signal, not a gate.
+        Clear abort marks for every swept tool record: terminal governance
+        failures can escape through any entry point, including wrapped errors.
+        Clearing is idempotent for activities that were never aborted.
         """
+        if self._activity_approvals is not None:
+            self._activity_approvals.end_turn(workflow_id)
         if self._core_runtime is None:
             return
         get_trace_registry(self._core_runtime).sweep(workflow_id)
@@ -663,27 +612,6 @@ class OpenBoxLangGraphHandler:
                 )
                 self._close_orphan_bridge_tool(workflow_id, record)
 
-    def _mark_bridge_abort(self, workflow_id: str, activity_id: str) -> None:
-        """Record (M19) that the base store's abort mark for `activity_id` was
-        set via the ToolNode-seam ContextVar path, NOT `register_activity` —
-        so `_cleanup_turn`'s `TraceContextRegistry.sweep` (which only clears
-        keys it registered) will never see it, and the mark would otherwise
-        leak on the runtime's `ContextStore` for the handler's lifetime.
-
-        No-op when this turn has no bridge (consumer-governed path — the
-        adapter's OWN abort-mark clearing there is exactly what `sweep`
-        already covers, via `register_activity`'s trace-only dual-write).
-        Safe to call with an activity_id the bridge never prepared (e.g. the
-        legacy synthetic `f"{run_id}-hook"` id from a base-hook approval,
-        C5's fallback branch) — `ActivityBridge.get` returns None and this is
-        a no-op, exactly matching pre-phase-4 behavior for that path.
-        """
-        if self._activity_bridge is None:
-            return
-        record = self._activity_bridge.get(workflow_id, activity_id)
-        if record is not None:
-            record.abort_marked = True
-
     def _close_orphan_bridge_tool(self, workflow_id: str, record: Any) -> None:
         """Best-effort failed ActivityCompleted for a swept orphan tool row.
 
@@ -714,27 +642,6 @@ class OpenBoxLangGraphHandler:
                 exc_info=True,
             )
 
-    def _reset_after_approval(self, workflow_id: str) -> None:
-        """Clear the abort mark(s) a hook set for this turn BEFORE an approved
-        REQUIRE_APPROVAL retry re-invokes the graph, so the retry runs
-        GOVERNED instead of short-circuiting on the stale abort flag the
-        blocked first pass left behind.
-
-        No-op when the handler has no core runtime (`_core_runtime is None`)
-        OR the runtime's adapter is the base default `CoreAdapter` (only
-        reachable when `use_core_instrumentation=False` — that adapter has no
-        `reset_after_approval`, matching this turn never having armed base
-        instrumentation in the first place, so there is nothing to reset).
-        Call BEFORE re-invoking the graph, AFTER `poll_until_decision`
-        resolves — matches `LangGraphFrameworkAdapter.reset_after_approval`'s
-        own ordering contract.
-        """
-        if self._core_runtime is None:
-            return
-        reset = getattr(self._core_runtime.adapter, "reset_after_approval", None)
-        if reset is not None:
-            reset(workflow_id)
-
     def _governed_config(
         self,
         config: dict[str, Any] | None,
@@ -782,6 +689,15 @@ class OpenBoxLangGraphHandler:
         untouched by this phase — see ``_process_event``'s LLMCompleted
         fallback branch.
         """
+        if self._core_runtime is not None and isinstance(
+            self._core_runtime.adapter, LangGraphFrameworkAdapter
+        ):
+            if self._activity_approvals is None:
+                self._activity_approvals = ActivityApprovalWaiter(
+                    self._core_runtime.client, self._config.hitl
+                )
+                self._core_runtime.adapter.approval_waiter = self._activity_approvals
+            self._activity_approvals.begin_turn(workflow_id, run_id)
         callbacks: list[Any] = []
         if self._activity_bridge is not None and self._core_runtime is not None:
             registry = get_trace_registry(self._core_runtime)
@@ -906,53 +822,10 @@ class OpenBoxLangGraphHandler:
                     output = stream_event.data.get("output")
                     if isinstance(output, dict):
                         final_output = output
-        except GovernanceBlockedError as hook_err:
-            if hook_err.verdict != "require_approval":
-                raise
-            _logger.info("[OpenBox] Hook REQUIRE_APPROVAL during ainvoke, polling")
-            poll_activity_id = _approval_poll_activity_id(hook_err, run_id)
-            self._mark_bridge_abort(workflow_id, poll_activity_id)
-            await poll_until_decision(
-                self._client,
-                HITLPollParams(
-                    workflow_id=workflow_id,
-                    run_id=run_id,
-                    activity_id=poll_activity_id,
-                    activity_type="hook",
-                ),
-                self._config.hitl,
-            )
-            _logger.info("[OpenBox] Approval granted, retrying ainvoke")
-            self._reset_after_approval(workflow_id)
-            final_output = await self._graph.ainvoke(input, config=cfg, **kwargs)
         except _CoreOpenBoxConfigError as exc:
             _raise_core_error(exc)
-        except Exception as exc:
-            hook_err = _extract_governance_blocked(exc)
-            if hook_err is None or hook_err.verdict != "require_approval":
-                raise
-            _logger.info("[OpenBox] Hook REQUIRE_APPROVAL (wrapped) during ainvoke, polling")
-            poll_activity_id = _approval_poll_activity_id(hook_err, run_id)
-            self._mark_bridge_abort(workflow_id, poll_activity_id)
-            await poll_until_decision(
-                self._client,
-                HITLPollParams(
-                    workflow_id=workflow_id,
-                    run_id=run_id,
-                    activity_id=poll_activity_id,
-                    activity_type="hook",
-                ),
-                self._config.hitl,
-            )
-            _logger.info("[OpenBox] Approval granted, retrying ainvoke")
-            self._reset_after_approval(workflow_id)
-            final_output = await self._graph.ainvoke(input, config=cfg, **kwargs)
         finally:
-            # Outermost `finally` on purpose: an approval retry re-runs the
-            # graph INSIDE the `except` blocks above, so this only fires once
-            # the (possibly retried) turn is fully done — the retry keeps its
-            # dual-write context intact instead of racing a cleanup that
-            # unregisters it mid-retry. See `_cleanup_turn`.
+            # Pending activities wait in place; the graph is never replayed.
             self._cleanup_turn(workflow_id)
 
         return final_output

{openbox_langgraph_sdk_python-1.1.0.dist-info → openbox_langgraph_sdk_python-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openbox-langgraph-sdk-python
-Version: 1.1.0
+Version: 1.2.0
 Summary: OpenBox governance and observability SDK for LangGraph
 License: MIT
 License-File: LICENSE
@@ -373,7 +373,17 @@ governed = create_openbox_graph_handler(
 )
 ```
 
-The human approves or rejects from the OpenBox dashboard. The SDK resumes or raises `ApprovalRejectedError` accordingly.
+The human approves or rejects from the OpenBox dashboard. Approval resumes the
+pending tool or hook operation with the same activity ID and graph state. Completed
+nodes and earlier tool side effects are not replayed. Later approval requests wait
+independently, including through `astream_governed` and `astream_events`. Rejection
+raises `ApprovalRejectedError`; expiration raises `ApprovalExpiredError`.
+
+Async operations await the decision without blocking the event loop. Synchronous
+tools wait in their executor thread. A synchronous operation called directly on the
+event-loop thread cannot safely suspend its stack, so pending approval raises
+`OpenBoxConfigError`; use an async operation or `asyncio.to_thread()` in that case.
+Cancelling the governed turn also stops pending approval waits.
 
 | Key | Type | Default | Description |
 |---|---|---|---|

{openbox_langgraph_sdk_python-1.1.0.dist-info → openbox_langgraph_sdk_python-1.2.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-openbox_langgraph/__init__.py,sha256=J-3oOgnRjF5ixC8r90vthDAVdotGI-fyg84byXvl4xQ,4142
+openbox_langgraph/__init__.py,sha256=dfDnwf1Nu6jQ7uFI_hSt5sOfNzHNhRXzQ-a-FhhJopc,4142
+openbox_langgraph/activity_approval.py,sha256=UTBq_XhP2hSrDO8UtQv_zUqyycx8fLRx2jvbc8qlIk4,5922
 openbox_langgraph/activity_context_binding.py,sha256=kI_Qu7R0mjM2js50sN3H-9CNWjzF8tI7Xg9afvnQeHo,4789
-openbox_langgraph/client.py,sha256=Asq9iw6BcazzIgRpyqP4KJOFris2ferOoz0u63EAtNo,26835
+openbox_langgraph/client.py,sha256=EaExu3PTWiB8NAkSTSoYpU-d-6tIqGg2pip2nLTpNLc,26835
 openbox_langgraph/config.py,sha256=XSbd5RMEsf1VWFQkCx7hJceTu_EcSs_uTMYL_LIybRE,17183
-openbox_langgraph/core_adapter.py,sha256=xv--ptTjoeAD7bo7IvJOhP_RRnKTkoAr06VY945yYBE,11418
+openbox_langgraph/core_adapter.py,sha256=8Xrc4TBoGgVxgzqrTHdkUYJNWWrd_NfG4bzNivZLTMs,8242
 openbox_langgraph/core_events.py,sha256=UXS9iWFPBLcClbfMa9MjaJDp4ZjMrm49x_oqX3TAZQg,6237
-openbox_langgraph/core_runtime.py,sha256=NRcjbbYnE-1sOaFM_rcmNpcAkufqTpRbn1L2WB0GXWk,8600
+openbox_langgraph/core_runtime.py,sha256=nKa1AQGL65SL_ct2FN2CqSG1U33vjjJW8gXPVWd-PoI,8600
 openbox_langgraph/errors.py,sha256=Xry_Ir6U2wmKerluIJ18eHPzuE5YCq0Ib1uY58raXro,5137
 openbox_langgraph/hitl.py,sha256=p8Xyxp9vvIBciumghM2RGJ53deIIwbufLRmw-PPLteU,2751
 openbox_langgraph/identity.py,sha256=t4jGkUNGz4OwcGXrWMgy5jVriEYJwCE_509Yi-MKaHY,5965
-openbox_langgraph/langgraph_handler.py,sha256=Ibp4wcBznlAh4qtH2nNiWGzCUX4YFZhrJF7pTSpLZaA,106043
+openbox_langgraph/langgraph_handler.py,sha256=TxaPuInh5iUACzoY63AM4uItZSiyJRwBrSfyIglj_Qo,99360
 openbox_langgraph/langgraph_hook_runtime.py,sha256=FVoTvay5ZJAI8iNxRCdPNEeldi7l50AMRGP_vmWU6G4,8757
 openbox_langgraph/otel_setup.py,sha256=Qk8GiXZ1f4WlSjT1_Id48dRfoZGkP_A0VCQFVX2wysU,1584
 openbox_langgraph/span_processor.py,sha256=MfsHG4La0P-G1mo2GCgFqU-al5iljExTAA1bSrCRtJA,14045
@@ -17,7 +18,7 @@ openbox_langgraph/trace_context_registry.py,sha256=fcU-WXt-8VLsyd8irJ1feQQCeLiGF
 openbox_langgraph/tracing.py,sha256=24CIs5hgnK2nRH0vF7g96L3fuxyP66w24Oe0sJbBCc8,7299
 openbox_langgraph/types.py,sha256=zUrk44-1PBWirW7bPPrsLcMNzJSVYCdpzPuu4iBwIXs,26368
 openbox_langgraph/verdict_handler.py,sha256=YmZjBxzOa2RBbkF13xDCPUAGzz7m1hwdMErwOVDl2WM,8323
-openbox_langgraph_sdk_python-1.1.0.dist-info/METADATA,sha256=sl6QbrHNXa8u8J0SRYzXb-3JReuTwVyl1BlD9hk8rHA,24140
-openbox_langgraph_sdk_python-1.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-openbox_langgraph_sdk_python-1.1.0.dist-info/licenses/LICENSE,sha256=bPyy7QFDMnA5r6asaR3iD9rQvpjz5cUFk1ouHCuBYIY,1071
-openbox_langgraph_sdk_python-1.1.0.dist-info/RECORD,,
+openbox_langgraph_sdk_python-1.2.0.dist-info/METADATA,sha256=C031jgvIgZHSzaNLNLwX5wNGbbGC54TqEfUVUuGHAA0,24815
+openbox_langgraph_sdk_python-1.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+openbox_langgraph_sdk_python-1.2.0.dist-info/licenses/LICENSE,sha256=bPyy7QFDMnA5r6asaR3iD9rQvpjz5cUFk1ouHCuBYIY,1071
+openbox_langgraph_sdk_python-1.2.0.dist-info/RECORD,,