langgraph-api 0.8.6__tar.gz → 0.9.0__tar.gz

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/Makefile

@@ -1,7 +1,7 @@
 .PHONY: build release lint format test test_watch start start-inmem start-inmem-license-oss start start-js-server build-go-server start-go-server stop-go-server check-version check-base-imports test-a2a-tck test-a2a-tck-mandatory start-test-a2a-tck start-test-a2a-tck-mandatory start-test-a2a-tck-watch test-mcp-conformance start-test-mcp-conformance list-mcp-scenarios
 
 # Environment variables
-LANGSERVE_GRAPHS_ALL = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "custom_lifespan": "./tests/graphs/my_router.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "agent_interrupt": "./tests/graphs/agent_interrupt.py:graph", "agent_parallel_interrupt": "./tests/graphs/agent_parallel_interrupt.py:graph", "message_type_test": "./tests/graphs/message_type_test.py:graph", "remote_subgraph_parent": "./tests/graphs/remote_subgraph_parent.py:graph", "simple_remote": "./tests/graphs/simple_remote.py:graph", "nested_subgraphs": "./tests/graphs/nested_subgraphs.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "max_concurrency_graph": "./tests/graphs/max_concurrency_graph.py:graph", "unserializable_subgraph": "./tests/graphs/unserializable_subgraph.py:graph", "agent_interrupt_text": "./tests/graphs/agent_interrupt_text.py:graph", "agent_echo_stream": "./tests/graphs/agent_echo_stream.py:graph", "agent_tool_stream": "./tests/graphs/agent_tool_stream.py:graph", "runtime_graph": "./tests/graphs/runtime_graph.py:graph", "tool_call_chunk_stream": "./tests/graphs/tool_call_chunk_stream.py:graph", "ui_tool_call_stream": "./tests/graphs/ui_tool_call_stream.py:graph", "agent_metrics_stream": "./tests/graphs/agent_metrics_stream.py:graph", "agent_multimodal_stream": "./tests/graphs/agent_multimodal_stream.py:graph", "agent_bedtime_story": "./tests/graphs/agent_bedtime_story.py:graph"}'
+LANGSERVE_GRAPHS_ALL = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "custom_lifespan": "./tests/graphs/my_router.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "agent_interrupt": "./tests/graphs/agent_interrupt.py:graph", "agent_parallel_interrupt": "./tests/graphs/agent_parallel_interrupt.py:graph", "message_type_test": "./tests/graphs/message_type_test.py:graph", "remote_subgraph_parent": "./tests/graphs/remote_subgraph_parent.py:graph", "simple_remote": "./tests/graphs/simple_remote.py:graph", "nested_subgraphs": "./tests/graphs/nested_subgraphs.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "max_concurrency_graph": "./tests/graphs/max_concurrency_graph.py:graph", "unserializable_subgraph": "./tests/graphs/unserializable_subgraph.py:graph", "agent_interrupt_text": "./tests/graphs/agent_interrupt_text.py:graph", "agent_echo_stream": "./tests/graphs/agent_echo_stream.py:graph", "agent_tool_stream": "./tests/graphs/agent_tool_stream.py:graph", "runtime_graph": "./tests/graphs/runtime_graph.py:graph", "tool_call_chunk_stream": "./tests/graphs/tool_call_chunk_stream.py:graph", "ui_tool_call_stream": "./tests/graphs/ui_tool_call_stream.py:graph", "agent_metrics_stream": "./tests/graphs/agent_metrics_stream.py:graph", "agent_multimodal_stream": "./tests/graphs/agent_multimodal_stream.py:graph", "agent_bedtime_story": "./tests/graphs/agent_bedtime_story.py:graph", "delta_channel": "./tests/graphs/delta_channel.py:graph", "delta_channel_freq": "./tests/graphs/delta_channel_freq.py:graph", "delta_channel_files": "./tests/graphs/delta_channel_files.py:graph", "delta_channel_files_freq": "./tests/graphs/delta_channel_files_freq.py:graph", "delta_channel_legacy": "./tests/graphs/delta_channel_migration.py:graph_legacy", "delta_channel_delta": "./tests/graphs/delta_channel_migration.py:graph_delta", "delta_channel_messages_freq": "./tests/graphs/delta_channel_messages.py:graph_freq", "delta_channel_messages": "./tests/graphs/delta_channel_messages.py:graph", "delta_channel_messages_legacy": "./tests/graphs/delta_channel_messages.py:graph_legacy", "delta_channel_messages_remove": "./tests/graphs/delta_channel_messages.py:graph_remove", "delta_channel_messages_update": "./tests/graphs/delta_channel_messages.py:graph_update", "delta_channel_messages_delta": "./tests/graphs/delta_channel_messages.py:graph_delta"}'
 LANGSERVE_GRAPHS_AUTH = '{"agent": {"path": "./tests/graphs/agent.py:graph", "description": "agent"}, "assistant_id_runtime": "./tests/graphs/assistant_id_runtime.py:graph", "config_graph": "./tests/graphs/config_graph.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph", "agent_parallel_interrupt": "./tests/graphs/agent_parallel_interrupt.py:graph", "functional_fibonacci": "./tests/graphs/functional_fibonacci.py:fibonacci", "state_graph_fibonacci": "./tests/graphs/state_graph_fibonacci.py:fibonacci", "runtime_graph": "./tests/graphs/runtime_graph.py:graph"}'
 
 # Go server management

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.8.6
+Version: 0.9.0
 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
 Requires-Python: >=3.11
 Requires-Dist: cloudpickle>=3.0.0
-Requires-Dist: cryptography<47.0,>=42.0.0
+Requires-Dist: cryptography>=42.0.0
 Requires-Dist: grpcio-health-checking<1.81.0,>=1.80.0
 Requires-Dist: grpcio-tools==1.80.0
 Requires-Dist: grpcio<1.81.0,>=1.80.0
@@ -16,7 +16,7 @@ Requires-Dist: jsonschema-rs<0.45,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langchain-protocol<0.1,>=0.0.15
 Requires-Dist: langgraph-checkpoint<5,>=3.0.1
-Requires-Dist: langgraph-runtime-inmem<0.29.0,>=0.28.0
+Requires-Dist: langgraph-runtime-inmem<0.30.0,>=0.29.0
 Requires-Dist: langgraph-sdk>=0.3.5
 Requires-Dist: langgraph<2,>=0.4.10
 Requires-Dist: langsmith[otel]>=0.6.3

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/benchmark/continuous/uv.lock

@@ -130,15 +130,15 @@ requires-dist = [
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.3.13"
+version = "0.3.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
     { name = "orjson" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/db/77a45127dddcfea5e4256ba916182903e4c31dc4cfca305b8c386f0a9e53/langgraph_sdk-0.3.13.tar.gz", hash = "sha256:419ca5663eec3cec192ad194ac0647c0c826866b446073eb40f384f950986cd5", size = 196360, upload-time = "2026-04-07T20:34:18.766Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/f1/134046c20bc4a4a15d410d1d21c9e298a3e9923777b4cc867b8669bc636b/langgraph_sdk-0.3.14.tar.gz", hash = "sha256:acd1674c538e97f3cdaa610f6dd7e34bc9bad30167f0ccc482dcd563325e81f5", size = 198162, upload-time = "2026-05-05T18:40:03.524Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ef/64d64e9f8eea47ce7b939aa6da6863b674c8d418647813c20111645fcc62/langgraph_sdk-0.3.13-py3-none-any.whl", hash = "sha256:aee09e345c90775f6de9d6f4c7b847cfc652e49055c27a2aed0d981af2af3bd0", size = 96668, upload-time = "2026-04-07T20:34:17.866Z" },
+    { url = "https://files.pythonhosted.org/packages/34/96/1c9f9fbfe756ddd850a2585e7f1949d8ebb97fdaa7a5eff8f45ed1314670/langgraph_sdk-0.3.14-py3-none-any.whl", hash = "sha256:68935bf6f4924eda92617a9e5dfb4f4281197508c648cb9d62ff083907607f9d", size = 97028, upload-time = "2026-05-05T18:40:02.099Z" },
 ]
 
 [[package]]
@@ -220,9 +220,9 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/benchmark/ramp.js

@@ -1,6 +1,8 @@
 import { sleep } from 'k6';
 import { Counter, Trend } from 'k6/metrics';
-import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';
+function randomIntBetween(min, max) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+}
 import { Benchmarks } from './benchmark-runners/dist/benchmarks.js';
 import { get_profile } from './benchmark-runners/dist/benchmark_profiles.js';
 

langgraph_api-0.9.0/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.0"

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/langgraph_api/api/__init__.py

@@ -15,11 +15,11 @@ from starlette.routing import BaseRoute, Route
 from langgraph_api import timing
 from langgraph_api.api.a2a import a2a_routes
 from langgraph_api.api.assistants import assistants_routes
+from langgraph_api.api.event_streaming import event_streaming_routes
 from langgraph_api.api.mcp import mcp_routes
 from langgraph_api.api.meta import meta_info, meta_metrics
 from langgraph_api.api.openapi import get_openapi_spec
 from langgraph_api.api.profile import profile_routes
-from langgraph_api.api.protocol import protocol_routes
 from langgraph_api.api.runs import runs_routes
 from langgraph_api.api.store import store_routes
 from langgraph_api.api.threads import threads_routes
@@ -31,7 +31,10 @@ from langgraph_api.config import (
     LANGGRAPH_ENCRYPTION,
     MIGRATIONS_PATH,
 )
-from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
+from langgraph_api.feature_flags import (
+    FF_V2_EVENT_STREAMING,
+    IS_POSTGRES_OR_GRPC_BACKEND,
+)
 from langgraph_api.graph import js_bg_tasks
 from langgraph_api.grpc.client import get_shared_client
 from langgraph_api.js.base import is_js_path
@@ -132,8 +135,20 @@ if HTTP_CONFIG:
         protected_routes.extend(mcp_routes)
     if not HTTP_CONFIG.get("disable_a2a"):
         protected_routes.extend(a2a_routes)
-    if not HTTP_CONFIG.get("disable_runs") and not HTTP_CONFIG.get("disable_protocol"):
-        protected_routes.extend(protocol_routes)
+    # ``disable_runs`` also gates event streaming because the v2 transport
+    # exposes run-creating commands (``run.start`` / ``run.cancel`` /
+    # ``run.attach`` over the WS, plus the ``/runs/{run_id}/protocol``
+    # attach route). If an operator hardens a deployment with
+    # ``disable_runs=true``, leaving event streaming open would be a
+    # backdoor that lets clients create runs anyway. ``disable_event_streaming``
+    # is the narrow knob (turn off just v2); ``disable_runs`` is the broad
+    # knob (no run-related functionality at all).
+    if (
+        FF_V2_EVENT_STREAMING
+        and not HTTP_CONFIG.get("disable_runs")
+        and not HTTP_CONFIG.get("disable_event_streaming")
+    ):
+        protected_routes.extend(event_streaming_routes)
 else:
     protected_routes.extend(assistants_routes)
     protected_routes.extend(runs_routes)
@@ -144,7 +159,8 @@ else:
     protected_routes.extend(ui_routes)
     protected_routes.extend(mcp_routes)
     protected_routes.extend(a2a_routes)
-    protected_routes.extend(protocol_routes)
+    if FF_V2_EVENT_STREAMING:
+        protected_routes.extend(event_streaming_routes)
 
 
 def _metadata_fn(app_import: str) -> dict[str, str]:

langgraph_api-0.8.6/langgraph_api/api/protocol.py → langgraph_api-0.9.0/langgraph_api/api/event_streaming.py

@@ -1,7 +1,9 @@
-"""Protocol v2 transport routes (thread-centric).
+"""V2 event streaming transport routes (thread-centric).
 
-The protocol is thread-centric (v0.5.0): every connection is scoped to a
-thread via the URL path, and there is no server-side session state.
+These routes implement the v2 event streaming protocol — see
+:mod:`langgraph_api.event_streaming` for the session/normalizer layer that
+shapes the wire events. Connections are scoped to a thread via the URL
+path; there is no server-side session state across connections.
 
 Endpoints:
 
@@ -19,6 +21,8 @@ Endpoints:
 from __future__ import annotations
 
 import asyncio
+import contextlib
+from collections import deque
 from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
@@ -27,10 +31,10 @@ import structlog
 from starlette.responses import Response
 from starlette.websockets import WebSocketDisconnect
 
+from langgraph_api.event_streaming.service import ThreadRunManager
+from langgraph_api.event_streaming.session import _is_supported_channel
+from langgraph_api.event_streaming.types import Subscription
 from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
-from langgraph_api.protocol.service import ThreadRunManager
-from langgraph_api.protocol.session import _is_supported_channel
-from langgraph_api.protocol.types import Subscription
 from langgraph_api.route import ApiRoute, ApiWebSocketRoute
 from langgraph_api.serde import json_dumpb
 from langgraph_api.sse import EventSourceResponse
@@ -47,6 +51,17 @@ else:
 logger = structlog.stdlib.get_logger(__name__)
 
 
+# Maximum number of recently-delivered ``event_id`` values an SSE
+# connection remembers for dedup. The dedup window only needs to cover
+# the brief race where a single event arrives both via the thread
+# source consumer and via the session's send callback (subscription
+# install handoff); after that, events flow through one path
+# consistently. Cap chosen with ample headroom — a pathological
+# replay storm of 2k events still fits in <50 KB of strings per
+# connection, vs. the unbounded set this replaces.
+_DELIVERED_DEDUP_WINDOW = 2048
+
+
 def _json_response(content: Any, *, status_code: int = 200) -> Response:
     """JSON response backed by the repo's orjson helper.
 
@@ -80,35 +95,6 @@ def _make_manager(thread_id: str, send_event: Any = None) -> ThreadRunManager:
 # ---------------------------------------------------------------------------
 
 
-def _parse_since(body: Any, headers: Any) -> int | None:
-    """Resolve the effective resume cursor from body and headers.
-
-    Precedence: ``since`` in the ``EventStreamRequest`` body wins, falling
-    back to the ``Last-Event-ID`` header. Both are interpreted as the
-    last protocol ``seq`` the client received; the server replays events
-    with ``seq > since``.
-    """
-    body_since: int | None = None
-    if isinstance(body, dict):
-        raw_since = body.get("since")
-        if isinstance(raw_since, int) and raw_since >= 0:
-            body_since = raw_since
-
-    header_since: int | None = None
-    last_event_id = headers.get("last-event-id") if headers is not None else None
-    if isinstance(last_event_id, str) and last_event_id.strip():
-        try:
-            parsed = int(last_event_id.strip())
-        except ValueError:
-            parsed = -1
-        if parsed >= 0:
-            header_since = parsed
-
-    if body_since is not None and header_since is not None:
-        return max(body_since, header_since)
-    return body_since if body_since is not None else header_since
-
-
 async def _thread_events(request: Request) -> Response:
     """SSE stream scoped to a thread.
 
@@ -121,12 +107,11 @@ async def _thread_events(request: Request) -> Response:
           "since": 42                                     // optional seq
         }
 
-    On reconnect, clients may either set ``since`` in the body or send the
-    standard ``Last-Event-ID`` header (the value of the ``id:`` field of
-    the last event they received). Both are interpreted as the last
-    ``seq`` the client saw; buffered events with ``seq > since`` are
-    replayed before the stream goes live. If both are provided, the
-    higher (most recent) value wins.
+    On reconnect, clients pass the last ``seq`` they received as
+    ``since`` in the body. Buffered events with ``seq > since`` are
+    replayed before the stream goes live. The endpoint is POST-only, so
+    browser-native ``EventSource`` auto-resume (``Last-Event-ID``)
+    doesn't apply — clients drive resume explicitly via the body.
 
     The filter applies for the lifetime of the connection; closing the
     connection unsubscribes. No state is persisted server-side beyond the
@@ -186,26 +171,45 @@ async def _thread_events(request: Request) -> Response:
         namespaces = filtered_ns or None
 
     depth = body.get("depth") if isinstance(body, dict) else None
-    if not isinstance(depth, int) or depth < 0:
+    # ``bool`` is a subclass of ``int``, so a JSON ``"depth": false`` would
+    # otherwise fall through as ``depth=0`` ("only the exact prefix
+    # namespace, no deeper") and silently mute every nested-subgraph
+    # event. Treat any non-int (including bool) as "no depth limit".
+    if not isinstance(depth, int) or isinstance(depth, bool) or depth < 0:
         depth = None
 
-    since = _parse_since(body, request.headers)
+    raw_since = body.get("since") if isinstance(body, dict) else None
+    # Reject ``bool`` explicitly — ``isinstance(True, int)`` is ``True``
+    # so a JSON ``"since": true`` would otherwise pass as ``since=1``
+    # and silently skip the first buffered event on reconnect.
+    since: int | None = (
+        raw_since
+        if isinstance(raw_since, int)
+        and not isinstance(raw_since, bool)
+        and raw_since >= 0
+        else None
+    )
 
+    # 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.
+    recent_eids: deque[str] = deque(maxlen=_DELIVERED_DEDUP_WINDOW)
     delivered: set[str] = set()
     pending_events: list[dict[str, Any]] = []
     flush_pending = asyncio.Event()
 
     async def on_event(event: dict[str, Any]) -> None:
         eid = event.get("event_id")
-        if eid is None:
-            return
-        if eid in delivered:
+        if eid is None or eid in delivered:
             return
         # Guard against events with seq <= since slipping through (e.g.
         # events delivered via the session's send callback before the
         # subscription is installed with replay).
         if since is not None and event.get("seq", 0) <= since:
             return
+        if len(recent_eids) == recent_eids.maxlen:
+            delivered.discard(recent_eids[0])
+        recent_eids.append(eid)
         delivered.add(eid)
         pending_events.append(event)
         flush_pending.set()
@@ -219,14 +223,47 @@ async def _thread_events(request: Request) -> Response:
         depth=depth,
         active=False,
     )
+    await logger.adebug(
+        "Installing event streaming subscription",
+        thread_id=thread_id,
+        subscription_id=filter_sub.id,
+        channels=sorted(filter_sub.channels),
+        depth=depth,
+        since=since,
+    )
 
     manager.install_subscription(filter_sub)
-    manager.start_thread_stream(since=since)
+    # ``since`` is enforced by ``on_event`` above as a seq filter on
+    # 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()
 
     async def body_iter():
         try:
             while True:
-                await flush_pending.wait()
+                # Race ``flush_pending`` against the thread-stream consumer
+                # ending. If the consumer dies (transient join_event_streaming
+                # error, or normal shutdown), we want this loop to exit
+                # rather than wedge forever waiting for events that will
+                # never arrive.
+                flush_task = asyncio.create_task(flush_pending.wait())
+                done_task = asyncio.create_task(manager.wait_for_thread_stream_end())
+                try:
+                    done, _pending = await asyncio.wait(
+                        {flush_task, done_task},
+                        return_when=asyncio.FIRST_COMPLETED,
+                    )
+                finally:
+                    for p in (flush_task, done_task):
+                        if not p.done():
+                            p.cancel()
+                            with contextlib.suppress(asyncio.CancelledError, Exception):
+                                await p
+                stream_finished = done_task in done
+                # Always drain whatever was buffered before exiting so a
+                # final batch that arrived alongside the consumer's exit
+                # still reaches the client.
                 flush_pending.clear()
                 events = pending_events[:]
                 pending_events.clear()
@@ -234,10 +271,10 @@ async def _thread_events(request: Request) -> Response:
                     # The wire ``event_id`` (inside the JSON body) carries
                     # the durable upstream Redis stream entry id used by
                     # the client's ``seenEventIds`` for cross-session
-                    # dedup. The SSE ``id:`` field needs a monotonic
-                    # integer so ``Last-Event-ID`` resume stays compatible
-                    # with :func:`_parse_since` (which parses it as an
-                    # ``int`` seq, session-local).
+                    # dedup. The SSE ``id:`` field carries the protocol
+                    # ``seq`` (session-local monotonic int) so server
+                    # logs and traces can correlate against the body
+                    # ``since`` cursor a reconnecting client sends.
                     sse_id = event.get("seq")
                     method = event.get("method", "event")
                     yield (
@@ -245,6 +282,8 @@ async def _thread_events(request: Request) -> Response:
                         json_dumpb(event),
                         str(sse_id).encode() if isinstance(sse_id, int) else None,
                     )
+                if stream_finished:
+                    break
         finally:
             await manager.close()
 
@@ -275,6 +314,13 @@ async def _thread_command(request: Request) -> Response:
         or not isinstance(payload.get("id"), int)
         or not isinstance(payload.get("method"), str)
     ):
+        await logger.awarning(
+            "Rejected malformed event streaming command",
+            thread_id=thread_id,
+            payload_id=payload.get("id") if isinstance(payload, dict) else None,
+            payload_method=payload.get("method") if isinstance(payload, dict) else None,
+            payload_type=type(payload).__name__,
+        )
         return _json_response(
             {
                 "type": "error",
@@ -316,6 +362,19 @@ async def _thread_websocket(websocket: WebSocket) -> None:
     manager = _make_manager(thread_id, send_event=ws_send_event)
     manager.start_thread_stream()
 
+    # Watchdog: when the thread-stream consumer ends (transient
+    # ``join_event_streaming`` failure or normal shutdown), close the socket so
+    # the client sees a clean disconnect instead of an open connection
+    # that will never deliver another event. ``receive_text`` below
+    # raises ``WebSocketDisconnect`` once the close lands, exiting the
+    # loop through its existing handler.
+    async def _stream_watchdog() -> None:
+        await manager.wait_for_thread_stream_end()
+        with contextlib.suppress(Exception):
+            await websocket.close(code=1011, reason="thread stream ended")
+
+    watchdog = asyncio.create_task(_stream_watchdog())
+
     try:
         while True:
             raw = await websocket.receive_text()
@@ -354,6 +413,9 @@ async def _thread_websocket(websocket: WebSocket) -> None:
     except Exception:
         logger.exception("Protocol WebSocket error")
     finally:
+        watchdog.cancel()
+        with contextlib.suppress(asyncio.CancelledError, Exception):
+            await watchdog
         await manager.close()
 
 
@@ -361,7 +423,7 @@ async def _thread_websocket(websocket: WebSocket) -> None:
 # Route list
 # ---------------------------------------------------------------------------
 
-protocol_routes: list[ApiRoute | ApiWebSocketRoute] = [
+event_streaming_routes: list[ApiRoute | ApiWebSocketRoute] = [
     ApiRoute(
         "/threads/{thread_id}/stream/events",
         _thread_events,

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/langgraph_api/api/runs.py

@@ -933,6 +933,7 @@ async def search_crons(request: ApiRequest):
             assistant_id=assistant_id,
             thread_id=thread_id,
             enabled=payload.get("enabled", None),
+            metadata=payload.get("metadata"),
             limit=int(payload.get("limit", 10)),
             offset=offset,
             sort_by=payload.get("sort_by"),
@@ -963,6 +964,7 @@ async def count_crons(request: ApiRequest):
             conn,
             assistant_id=assistant_id,
             thread_id=thread_id,
+            metadata=payload.get("metadata"),
         )
     return ApiResponse(count)
 

{langgraph_api-0.8.6 → langgraph_api-0.9.0}/langgraph_api/config/__init__.py

@@ -45,6 +45,16 @@ DATABASE_URI = env("DATABASE_URI", cast=str, default=getenv("POSTGRES_URI", unde
 # Not in public docs: infrastructure, set by platform
 MIGRATIONS_PATH = env("MIGRATIONS_PATH", cast=str, default="/storage/migrations")
 POSTGRES_POOL_MAX_SIZE = env("LANGGRAPH_POSTGRES_POOL_MAX_SIZE", cast=int, default=150)
+CHECKPOINTER_POSTGRES_POOL_MIN_SIZE = env(
+    "LANGGRAPH_CHECKPOINTER_POSTGRES_POOL_MIN_SIZE",
+    cast=int,
+    default=1,
+)
+CHECKPOINTER_POSTGRES_POOL_TIMEOUT_SECONDS = env(
+    "LANGGRAPH_CHECKPOINTER_POSTGRES_POOL_TIMEOUT_SECONDS",
+    cast=float,
+    default=15.0,
+)
 
 # Checkpoint ingestion batch controls
 # Go defaults (core/config/config.go): CHECKPOINT_MAX_BATCH_SIZE=1000, CHECKPOINT_BATCH_DELAY=0.005 (5ms)
@@ -182,15 +192,15 @@ LSD_GRPC_SERVER_MAX_SEND_MSG_BYTES = env(
     "LSD_GRPC_SERVER_MAX_SEND_MSG_BYTES", cast=int, default=300 * 1024 * 1024
 )
 LSD_PUBLISH_QUEUE_SIZE = env("LSD_PUBLISH_QUEUE_SIZE", cast=int, default=512)
-# Per-run protocol v2 event buffer size. Each ``RunProtocolSession``
+# Per-run protocol v2 event buffer size. Each ``EventStreamingSession``
 # retains at most this many normalized protocol events for
-# reconnecting clients to replay via ``since`` / ``Last-Event-ID``.
+# reconnecting clients to replay via the body ``since`` cursor.
 # When the limit is exceeded, oldest events are evicted; reconnects
 # whose cursor falls behind the buffer head receive a ``resume_gap``
 # error. Operators running graphs that emit >10k events per run can
 # bump this to avoid gaps on flaky networks, at the cost of memory
 # (roughly ``size * avg_event_bytes`` per active run). See
-# ``langgraph_api.protocol.constants.DEFAULT_MAX_BUFFER_SIZE``.
+# ``langgraph_api.event_streaming.constants.DEFAULT_MAX_BUFFER_SIZE``.
 _DEFAULT_PROTOCOL_V2_BUFFER_SIZE = 10_000
 LSD_PROTOCOL_V2_BUFFER_SIZE = env(
     "LSD_PROTOCOL_V2_BUFFER_SIZE",
@@ -616,6 +626,8 @@ __all__ = [
     "BG_JOB_SHUTDOWN_GRACE_PERIOD_SECS",
     "BG_JOB_TIMEOUT_SECS",
     "CHECKPOINTER_CONFIG",
+    "CHECKPOINTER_POSTGRES_POOL_MIN_SIZE",
+    "CHECKPOINTER_POSTGRES_POOL_TIMEOUT_SECONDS",
     "CHECKPOINT_BATCH_DELAY",
     "CHECKPOINT_MAX_BATCH_SIZE",
     "CORS_ALLOW_ORIGINS",

{langgraph_api-0.8.6/langgraph_api/protocol → langgraph_api-0.9.0/langgraph_api/event_streaming}/capabilities.py

@@ -57,12 +57,21 @@ class ProtocolV2Capabilities:
 
     ok: bool
     missing: tuple[str, ...]
+    # Replaces the default "missing langgraph symbols" wording when the
+    # server has disabled v2 deliberately (e.g. ``FF_V2_EVENT_STREAMING=false``).
+    # Library-version mismatches and operator-disabled v2 produce the same
+    # ``unsupported`` envelope, but with very different ``"upgrade your
+    # deps"`` vs ``"flip the flag"`` remediation paths — keep them
+    # distinguishable in the error string.
+    reason_override: str | None = None
 
     @property
     def error_message(self) -> str:
         """Human-readable explanation suitable for a command error envelope."""
         if self.ok:
             return ""
+        if self.reason_override is not None:
+            return self.reason_override
         return (
             "Protocol v2 streaming is not supported by the installed "
             "langgraph/langchain-core version. Missing symbol(s): "
@@ -73,6 +82,18 @@ class ProtocolV2Capabilities:
             "LifecycleTransformer, and ChatModelStream)."
         )
 
+    @classmethod
+    def disabled_by_flag(cls) -> ProtocolV2Capabilities:
+        """Build a capabilities result for ``FF_V2_EVENT_STREAMING=false``."""
+        return cls(
+            ok=False,
+            missing=(),
+            reason_override=(
+                "Protocol v2 event streaming is disabled on this server "
+                "(FF_V2_EVENT_STREAMING=false). Set FF_V2_EVENT_STREAMING=true to enable."
+            ),
+        )
+
 
 # Submodule paths are intentional — ``StreamMux`` et al. are not
 # re-exported from ``langgraph.stream`` / ``langgraph.pregel`` top-level,
@@ -90,7 +111,7 @@ _REQUIRED_SYMBOLS: tuple[tuple[str, str], ...] = (
 
 
 @lru_cache(maxsize=1)
-def probe_protocol_v2_capabilities() -> ProtocolV2Capabilities:
+def probe_event_streaming_v2_capabilities() -> ProtocolV2Capabilities:
     """Check the installed runtime for Protocol v2 streaming support.
 
     Result is memoised for the process lifetime — the underlying

{langgraph_api-0.8.6/langgraph_api/protocol → langgraph_api-0.9.0/langgraph_api/event_streaming}/constants.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-PROTOCOL_MESSAGES_STREAM_CONFIG_KEY = "__protocol_messages_stream"
+EVENT_STREAMING_V2_CONFIG_KEY = "__event_streaming_v2"
 
-# Ring-buffer size for ``RunProtocolSession``. Events beyond this point
+# Ring-buffer size for ``EventStreamingSession``. Events beyond this point
 # are dropped (oldest-first) from the replay buffer. Internal
 # memory-safety cap — not tunable over the wire, but operators can
 # override via the ``LSD_PROTOCOL_V2_BUFFER_SIZE`` env var (see