langgraph-api 0.18.0.dev3__tar.gz → 0.18.0.dev5__tar.gz

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev3
+Version: 0.18.0.dev5
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.18.0.dev5/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0.dev5"

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/api/event_streaming.py

@@ -28,6 +28,7 @@ from uuid import uuid4
 
 import orjson
 import structlog
+from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.websockets import WebSocketDisconnect
 
@@ -38,6 +39,7 @@ from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
 from langgraph_api.route import ApiRoute, ApiWebSocketRoute
 from langgraph_api.serde import json_dumpb
 from langgraph_api.sse import EventSourceResponse
+from langgraph_api.utils import validate_uuid
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -98,6 +100,7 @@ def _make_manager(
     send_event: Any = None,
     *,
     headers: Mapping[str, str] | None = None,
+    replay_buffer: bool = True,
 ) -> ThreadRunManager:
     # Auth context is propagated via ``ApiRoute``'s ``with_user`` wrapper
     # — ops reads it off the context var, so we don't thread it through
@@ -108,6 +111,7 @@ def _make_manager(
         threads=Threads,
         send_event=send_event,
         headers=headers,
+        replay_buffer=replay_buffer,
     )
 
 
@@ -143,8 +147,12 @@ async def _thread_events(request: Request) -> Response:
         If reading the thread's event stream fails, the server ends the
         stream with a final ``event: error`` frame carrying a protocol error
         (``"type": "error"``, ``"id": null``, ``"error": "unknown_error"``).
+
+        A thread the caller isn't allowed to read returns 403 or 404 before
+        the stream starts, and a malformed thread ID returns 422.
     """
     thread_id = request.path_params["thread_id"]
+    thread_uuid = validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     try:
         body = orjson.loads(await request.body())
     except Exception:
@@ -217,6 +225,10 @@ async def _thread_events(request: Request) -> Response:
         else None
     )
 
+    # Checked here, before the 200, because clients retry a 200 that ends in
+    # an error instead of giving up.
+    auth_filters = await Threads.Stream.check_thread_stream_auth(thread_uuid)
+
     # Bounded LRU dedup: ``recent_eids`` is the eviction order, ``delivered``
     # is the O(1) membership view. When the deque hits its cap, the oldest
     # entry rolls off; we mirror that on ``delivered`` to keep them in sync.
@@ -241,7 +253,10 @@ async def _thread_events(request: Request) -> Response:
         pending_events.append(event)
         flush_pending.set()
 
-    manager = _make_manager(thread_id, send_event=on_event)
+    # SSE never replays from the session's buffer: it has no subscribe or
+    # reconnect commands, and ``start_thread_stream`` replays from the
+    # thread's event stream.
+    manager = _make_manager(thread_id, send_event=on_event, replay_buffer=False)
 
     filter_sub = Subscription(
         id=str(uuid4()),
@@ -264,7 +279,7 @@ async def _thread_events(request: Request) -> Response:
     # outbound events; the thread-level reader always replays from the
     # beginning so namespace-scoped projections see history. See
     # ``ThreadRunManager.start_thread_stream`` for the rationale.
-    manager.start_thread_stream()
+    manager.start_thread_stream(auth_filters=auth_filters)
 
     async def body_iter():
         try:
@@ -377,20 +392,51 @@ async def _thread_command(request: Request) -> Response:
 # ---------------------------------------------------------------------------
 
 
+async def _close_for_failed_access_check(websocket: WebSocket, exc: Exception) -> None:
+    if isinstance(exc, HTTPException) and exc.status_code < 500:
+        await websocket.close(code=4000 + exc.status_code)
+        return
+    logger.exception("Thread stream access check failed")
+    await websocket.send_text(_THREAD_STREAM_FAILED_DATA.decode())
+    await websocket.close(code=1011, reason="thread stream ended")
+
+
 async def _thread_websocket(websocket: WebSocket) -> None:
     """Full-duplex protocol connection scoped to a thread.
 
     Supports ``run.start``, ``input.respond``, ``subscription.subscribe``,
     ``subscription.unsubscribe``, ``agent.getTree``.
+
+    A 4xx from the thread's access check closes the socket with 4000 plus the
+    status (4403, 4422). A 404 can be a thread the client minted and has yet
+    to create, so the socket then waits for a ``run.start``, which checks
+    access like any run start, and closes with 4404 if another command comes
+    first. Any other failure of the check, a 5xx included, gets the stream
+    error frame and a 1011 close, as when the stream fails later.
     """
     thread_id = websocket.path_params["thread_id"]
+    # Browsers report a refused upgrade only as a 1006 close, so accept first
+    # to make the close code readable.
     await websocket.accept()
+    try:
+        thread_uuid = validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+    except HTTPException as exc:
+        await _close_for_failed_access_check(websocket, exc)
+        return
+    awaiting_thread = False
+    auth_filters: Any = None
+    try:
+        auth_filters = await Threads.Stream.check_thread_stream_auth(thread_uuid)
+    except Exception as exc:
+        if not (isinstance(exc, HTTPException) and exc.status_code == 404):
+            await _close_for_failed_access_check(websocket, exc)
+            return
+        awaiting_thread = True
 
     async def ws_send_event(event: dict[str, Any]) -> None:
         await websocket.send_text(orjson.dumps(event).decode("utf-8"))
 
     manager = _make_manager(thread_id, send_event=ws_send_event)
-    manager.start_thread_stream()
 
     # Watchdog: when the thread-stream consumer stops, send the error frame
     # (if it wasn't cancelled) and close the socket, instead of leaving the
@@ -405,7 +451,11 @@ async def _thread_websocket(websocket: WebSocket) -> None:
         with contextlib.suppress(Exception):
             await websocket.close(code=1011, reason="thread stream ended")
 
-    watchdog = asyncio.create_task(_stream_watchdog())
+    def start_stream(filters: Any) -> asyncio.Task[None]:
+        manager.start_thread_stream(auth_filters=filters)
+        return asyncio.create_task(_stream_watchdog())
+
+    watchdog = None if awaiting_thread else start_stream(auth_filters)
 
     try:
         while True:
@@ -438,16 +488,30 @@ async def _thread_websocket(websocket: WebSocket) -> None:
                 )
                 continue
 
+            if awaiting_thread and payload["method"] != "run.start":
+                await websocket.close(code=4404)
+                return
             response = await manager.handle_command(payload)
             await websocket.send_text(orjson.dumps(response).decode("utf-8"))
+            if awaiting_thread and response.get("type") == "success":
+                try:
+                    auth_filters = await Threads.Stream.check_thread_stream_auth(
+                        thread_uuid
+                    )
+                except Exception as exc:
+                    await _close_for_failed_access_check(websocket, exc)
+                    return
+                watchdog = start_stream(auth_filters)
+                awaiting_thread = False
     except WebSocketDisconnect:
         pass
     except Exception:
         logger.exception("Protocol WebSocket error")
     finally:
-        watchdog.cancel()
-        with contextlib.suppress(asyncio.CancelledError, Exception):
-            await watchdog
+        if watchdog is not None:
+            watchdog.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await watchdog
         await manager.close()
 
 

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/config/__init__.py

@@ -507,7 +507,8 @@ FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)
 FF_LOG_DROPPED_EVENTS = env("FF_LOG_DROPPED_EVENTS", cast=bool, default=False)
 FF_LOG_QUERY_AND_PARAMS = env("FF_LOG_QUERY_AND_PARAMS", cast=bool, default=False)
 # Opt-in handling of drained runs: the server's control signalling to the
-# graph and its handling of drained runs, together.
+# graph and its handling of drained runs, together. On, a Postgres-backed
+# replica that is shutting down also drains its in-flight runs.
 # Off: no control is created or seeded, and GraphDrained lands in the
 # catch-all error branch.
 FF_RESUME_DRAINED_RUNS = env("FF_RESUME_DRAINED_RUNS", cast=bool, default=False)
@@ -535,8 +536,6 @@ RESUME_DRAINED_RUNS = _resolve_resume_drained_runs(
     is_postgres=IS_POSTGRES_BACKEND,
     langgraph_supported=DRAIN_RESUME_SUPPORT,
 )
-# Not in public docs: internal feature flag
-FF_USE_REDIS_QUEUE = env("FF_USE_REDIS_QUEUE", cast=bool, default=True)
 
 
 # Internal flag intended for testing only
@@ -811,7 +810,6 @@ __all__ = [
     "FF_PYSPY_PROFILING_ENABLED",
     "FF_PYSPY_PROFILING_MAX_DURATION_SECS",
     "FF_RESUME_DRAINED_RUNS",
-    "FF_USE_REDIS_QUEUE",
     "GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE",
     "GRPC_CLIENT_MAX_RECV_MSG_BYTES",
     "GRPC_CLIENT_MAX_SEND_MSG_BYTES",

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/drain.py

@@ -10,6 +10,7 @@ guarded and the placeholders below never match or instantiate anything.
 from __future__ import annotations
 
 import contextvars
+import threading
 from typing import Any
 
 # The control of the run whose top-level graph this context is executing. The
@@ -47,17 +48,35 @@ try:
         The request is visible only where this is provably the run's top-level
         loop: in a context the server marked for this control (see
         mark_top_level) and outside any graph node. So the run drains only at
-        a top-level step boundary, after that step's subgraphs have finished.
+        a top-level step boundary, after that step's subgraphs have finished,
+        and never before its first step.
         Graph code inside a node, and threads a node starts, see no drain
         (drain_requested False, drain_reason None).
         """
 
+        __slots__ = ("_first_check_done",)
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._first_check_done = False
+
         def _visible(self) -> bool:
             return _TOP_LEVEL_CONTROL.get() is self and not _in_graph_node()
 
         @property
         def drain_requested(self) -> bool:
-            return self._visible() and RunControl.drain_requested.fget(self)
+            if not self._visible():
+                return False
+            # LangGraph checks once per top-level step boundary, before the
+            # step. Only a server drain can be pending at the first check. A
+            # run started with a Command has no checkpoint of its own until its
+            # first step ends, so if it drained there, its next claim would
+            # re-send the Command and LangGraph would apply it again. So a run
+            # always completes a step before it drains.
+            if not self._first_check_done:
+                self._first_check_done = True
+                return False
+            return RunControl.drain_requested.fget(self)
 
         @property
         def drain_reason(self) -> str | None:
@@ -79,6 +98,11 @@ except ImportError:
 
     DRAIN_SUPPORT = False
 
+# Reason the server passes to request_drain() when its pod is shutting down.
+# Graph code can pass any reason (request_drain() defaults to "shutdown"), so
+# this distinct value is what tells server drains from graph drains in logs.
+SERVER_SHUTDOWN_DRAIN_REASON = "server_shutdown"
+
 
 def mark_top_level(control: ServerRunControl | None) -> None:
     """Mark the current context as running ``control``'s top-level graph."""
@@ -92,10 +116,48 @@ def new_run_control() -> ServerRunControl | None:
     return None
 
 
+class RunControlRegistry:
+    """Controls of the runs a queue drains at shutdown, keyed by run ID.
+
+    Workers can finish on background threads (isolated loops), so every access
+    takes a lock and ``drain_all`` works on a snapshot. Controls are registered
+    before the run starts, and removed only by the claim that registered them,
+    so a fast-finishing or superseded claim can't leave or remove the wrong
+    entry.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._controls: dict[str, ServerRunControl] = {}
+
+    def add(self, run_id: Any, control: ServerRunControl) -> None:
+        """Register a run's control before the run starts."""
+        with self._lock:
+            self._controls[str(run_id)] = control
+
+    def release(self, run_id: Any, control: ServerRunControl | None) -> None:
+        """Remove a run's control if it is still the one this claim registered."""
+        if control is None:
+            return
+        with self._lock:
+            if self._controls.get(str(run_id)) is control:
+                del self._controls[str(run_id)]
+
+    def drain_all(self, reason: str) -> int:
+        """Request a drain from every registered run; return how many."""
+        with self._lock:
+            controls = list(self._controls.values())
+        for control in controls:
+            control.request_drain(reason)
+        return len(controls)
+
+
 __all__ = [
     "DRAIN_SUPPORT",
+    "SERVER_SHUTDOWN_DRAIN_REASON",
     "GraphDrained",
     "RunControl",
+    "RunControlRegistry",
     "ServerRunControl",
     "mark_top_level",
     "new_run_control",

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/event_streaming/service.py

@@ -46,6 +46,7 @@ from langgraph_api.event_streaming.session import (
 from langgraph_api.event_streaming.types import Subscription
 from langgraph_api.feature_flags import FF_V2_EVENT_STREAMING, PREFER_GRPC_CHECKPOINTER
 from langgraph_api.schema import MultitaskStrategy
+from langgraph_api.validation import sanitize_reserved_keys
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -192,6 +193,9 @@ class ThreadRunManager:
     One ``ThreadRunManager`` is created per connection (HTTP SSE stream or
     WebSocket). It is not shared across connections — each observer owns
     its own view of the thread's run stream.
+
+    ``replay_buffer=False`` keeps no per-run replay buffer, for connections
+    that never replay from it.
     """
 
     def __init__(
@@ -202,12 +206,14 @@ class ThreadRunManager:
         threads: Any,
         send_event: EventSink | None = None,
         headers: Mapping[str, str] | None = None,
+        replay_buffer: bool = True,
     ) -> None:
         self._thread_id = thread_id
         self._runs = runs
         self._threads = threads
         self._send_event = send_event
         self._headers = headers if headers is not None else {}
+        self._replay_buffer = replay_buffer
         self._session: EventStreamingSession | None = None
         self._current_run_id: str | None = None
         self._queued_events: list[dict[str, Any]] = []
@@ -291,7 +297,7 @@ class ThreadRunManager:
                 active=True,
             )
 
-    def start_thread_stream(self) -> None:
+    def start_thread_stream(self, *, auth_filters: Any = None) -> None:
         """Start consuming the thread-level stream for this connection.
 
         Always start from the beginning of the thread's event stream
@@ -306,14 +312,19 @@ class ThreadRunManager:
         produce output…". The SSE/WS sink applies the caller's ``since``
         as a seq filter on outbound events, and the SDK dedups by
         ``event_id``, so repeat observers don't see duplicates.
+
+        ``auth_filters`` is what the route's ``check_thread_stream_auth``
+        returned, passed on so the stream doesn't run the read handler again.
         """
         if self._thread_source_task is not None:
             return
         self._thread_source_task = asyncio.create_task(
-            self._consume_thread_stream(last_event_id="-")
+            self._consume_thread_stream(last_event_id="-", auth_filters=auth_filters)
         )
 
-    async def _consume_thread_stream(self, *, last_event_id: str | None) -> None:
+    async def _consume_thread_stream(
+        self, *, last_event_id: str | None, auth_filters: Any
+    ) -> None:
         try:
             async for (
                 event,
@@ -324,6 +335,7 @@ class ThreadRunManager:
                 self._thread_id,
                 stream_modes=["run_modes", "lifecycle"],
                 last_event_id=last_event_id,
+                auth_filters=auth_filters,
             ):
                 if not run_id or run_id == "*":
                     continue
@@ -781,6 +793,9 @@ class ThreadRunManager:
         if not capabilities.ok:
             raise ProtocolV2UnsupportedError(capabilities)
 
+        # Drop server-owned configurable and metadata keys before the run
+        # config is built, as the REST request parser does for its bodies.
+        sanitize_reserved_keys(params)
         config = params.get("config") if _is_record(params.get("config")) else {}
 
         # ``input.respond`` checked its interrupts already and always resumes;
@@ -959,6 +974,7 @@ class ThreadRunManager:
             get_thread_state=self._make_get_thread_state(thread_id),
             source=None,
             send=self._make_send(),
+            max_buffer_size=None if self._replay_buffer else 0,
         )
 
         self._session = session

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/event_streaming/session.py

@@ -228,8 +228,8 @@ class EventStreamingSession:
     ) -> None:
         if max_buffer_size is None:
             max_buffer_size = LSD_PROTOCOL_V2_BUFFER_SIZE
-        if max_buffer_size < 1:
-            raise ValueError("max_buffer_size must be a positive integer")
+        if max_buffer_size < 0:
+            raise ValueError("max_buffer_size must be zero or a positive integer")
         self._run_id = run_id
         self._thread_id = thread_id
         self._initial_run = initial_run
@@ -251,6 +251,7 @@ class EventStreamingSession:
         self._buffer: list[dict[str, Any]] = []
         self._source_task: asyncio.Task[None] | None = None
         self._next_seq = 0
+        # 0 keeps no replay buffer, for transports that never replay from it.
         self._max_buffer_size = max_buffer_size
         self._root_graph_name = "root"
         self._terminal_lifecycle_emitted = False
@@ -971,7 +972,8 @@ class EventStreamingSession:
         return _synth_event_id(self._run_id, str(self._next_seq))
 
     async def _push_event(self, event: dict[str, Any]) -> None:
-        self._buffer.append(event)
+        if self._max_buffer_size:
+            self._buffer.append(event)
         reporter = get_otlp_metrics_reporter()
         if len(self._buffer) > self._max_buffer_size:
             evicted = len(self._buffer) - self._max_buffer_size
@@ -1036,9 +1038,10 @@ class EventStreamingSession:
         callback for events with ``seq > since`` that match the filter,
         then the subscription is activated so live events flow.
 
-        Returns the number of events replayed. Used by both the WebSocket
-        ``subscription.subscribe`` command and the SSE event stream, which
-        accept a body ``since`` cursor to resume after a reconnect.
+        Returns the number of events replayed. Used by the WebSocket
+        ``subscription.subscribe`` and ``subscription.reconnect`` commands;
+        ``since`` resumes after a reconnect. SSE streams replay from the
+        thread's event stream instead.
 
         Raises :class:`ResumeGap` when *since* is older than the
         session's retained buffer head. This lets callers surface a

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/grpc/ops/threads.py

@@ -68,6 +68,10 @@ logger = structlog.stdlib.get_logger(__name__)
 # only need graph_id (from metadata) and the thread config.
 THREAD_METADATA_READ_MASK_PATHS: list[str] = ["metadata", "config"]
 
+# Read-mask preset for an auth/existence check that discards the thread body;
+# Go's ``repos.ThreadExistenceCheckMask``.
+THREAD_EXISTENCE_CHECK_READ_MASK_PATHS: list[str] = []
+
 
 THREAD_STATUS_TO_PB = {
     "idle": enum_thread_status.idle,
@@ -971,13 +975,20 @@ class Threads(Authenticated):
             stream_modes: list[str] | None = None,
             last_event_id: str | None = None,
             ctx: Any = None,
+            auth_filters: list[pb.AuthFilter] | None = None,
         ):
-            """Stream thread events with their run id for protocol demux."""
-            auth_filters = await Threads.Stream.handle_event(
-                ctx,
-                "read",
-                Auth.types.ThreadsRead(thread_id=UUID(str(thread_id))),
-            )
+            """Stream thread events with their run id for protocol demux.
+
+            ``auth_filters`` comes from a ``check_thread_stream_auth`` the
+            caller already ran, so the read handler doesn't run twice. With
+            ``None``, the handler runs here.
+            """
+            if auth_filters is None:
+                auth_filters = await Threads.Stream.handle_event(
+                    ctx,
+                    "read",
+                    Auth.types.ThreadsRead(thread_id=UUID(str(thread_id))),
+                )
 
             stream_modes_pb = _map_thread_stream_modes(stream_modes)
 
@@ -1013,6 +1024,43 @@ class Threads(Authenticated):
                     _handle_grpc_error(e)
                 raise
 
+        @staticmethod
+        async def check_thread_stream_auth(
+            thread_id: UUID,
+            ctx: Any = None,
+        ) -> list[pb.AuthFilter]:
+            """Raise 403/404 before a thread stream's response starts.
+
+            Same check as the Go ``Stream`` RPC: the thread is looked up only
+            when custom auth returns filters. Without filters, a thread that
+            doesn't exist yet must stay streamable, because the Python SDK
+            opens its lifecycle stream on ``async with client.threads.stream()``,
+            before the ``run.start`` that creates the thread.
+
+            Returns the auth filters for ``join_event_streaming``.
+            """
+            auth_filters = await Threads.Stream.handle_event(
+                ctx,
+                "read",
+                Auth.types.ThreadsRead(thread_id=thread_id),
+            )
+            if not auth_filters:
+                return auth_filters
+            client = await get_shared_client()
+            try:
+                await client.threads.Get(
+                    pb.GetThreadRequest(
+                        thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+                        filters=auth_filters,
+                        read_mask=field_mask_pb2.FieldMask(
+                            paths=THREAD_EXISTENCE_CHECK_READ_MASK_PATHS
+                        ),
+                    )
+                )
+            except AioRpcError as e:
+                _handle_grpc_error(e)
+            return auth_filters
+
     class State(Authenticated):
         # treat this like threads resource
         resource = "threads"

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/models/run.py

@@ -36,6 +36,7 @@ from langgraph_api.tracing_session import resolve_tracing_session_name
 from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx, get_user_id
 from langgraph_api.utils.headers import get_configurable_headers
 from langgraph_api.utils.uuids import uuid7
+from langgraph_api.validation import strip_reserved
 from langgraph_api.webhook import validate_webhook_url_or_raise
 
 if IS_POSTGRES_OR_GRPC_BACKEND:
@@ -261,6 +262,12 @@ async def create_valid_run(
     if checkpoint_id:
         configurable["checkpoint_id"] = str(checkpoint_id)
     if checkpoint := payload.get("checkpoint"):
+        # Cron payloads stored before requests had checkpoint stripped can still carry server-owned keys.
+        strip_reserved(
+            checkpoint,
+            "checkpoint",
+            message="Stripped reserved keys from stored checkpoint",
+        )
         configurable.update(checkpoint)
     configurable.update(get_configurable_headers(headers))
     # cron_id is server-owned: drop any value merged from the request, then stamp the scheduler's.

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/utils/headers.py

@@ -8,6 +8,8 @@ from collections.abc import Mapping
 import orjson
 import structlog
 
+from langgraph_api.validation import RESERVED_CONFIGURABLE_KEYS
+
 logger = structlog.stdlib.get_logger(__name__)
 
 LANGSMITH_METADATA = "langsmith-metadata"
@@ -146,6 +148,9 @@ def should_include_header(key: str) -> bool:
         or key == "authorization"
     ):
         return False
+    # Server-owned configurable keys are never taken from a request header.
+    if key in RESERVED_CONFIGURABLE_KEYS:
+        return False
 
     include_patterns, exclude_patterns = get_header_patterns("configurable_headers")
 

{langgraph_api-0.18.0.dev3 → langgraph_api-0.18.0.dev5}/langgraph_api/validation.py

@@ -112,7 +112,7 @@ _RESERVED_KEYS_SET = frozenset(RESERVED_CONFIGURABLE_KEYS)
 _RESERVED_METADATA_KEYS_SET = frozenset(RESERVED_METADATA_KEYS)
 
 
-def _strip_reserved(
+def strip_reserved(
     d: dict,
     location: str,
     reserved_keys: frozenset[str] = _RESERVED_KEYS_SET,
@@ -134,7 +134,7 @@ def _strip_metadata(d: dict, location: str) -> None:
     """Strip reserved keys from a ``metadata`` sub-dict if present."""
     metadata = d.get("metadata")
     if isinstance(metadata, dict):
-        _strip_reserved(
+        strip_reserved(
             metadata,
             location,
             reserved_keys=_RESERVED_METADATA_KEYS_SET,
@@ -184,22 +184,22 @@ def sanitize_reserved_keys(data: typing.Any, *, strip_metadata: bool = True) ->
     if isinstance(config, dict):
         configurable = config.get("configurable")
         if isinstance(configurable, dict):
-            _strip_reserved(configurable, "config.configurable")
+            strip_reserved(configurable, "config.configurable")
 
     # Config schema: top-level configurable
     configurable = data.get("configurable")
     if isinstance(configurable, dict):
-        _strip_reserved(configurable, "configurable")
+        strip_reserved(configurable, "configurable")
 
     # write schemas: context
     context = data.get("context")
     if isinstance(context, dict):
-        _strip_reserved(context, "context")
+        strip_reserved(context, "context")
 
     # checkpoint: merged into configurable on run create and when a cron fires
     checkpoint = data.get("checkpoint")
     if isinstance(checkpoint, dict):
-        _strip_reserved(checkpoint, "checkpoint")
+        strip_reserved(checkpoint, "checkpoint")
 
 
 def should_strip_reserved_metadata(schema: typing.Any) -> bool: