langgraph-api 0.11.0.dev5__tar.gz → 0.11.0.dev6__tar.gz

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.11.0.dev5
+Version: 0.11.0.dev6
 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.11.0.dev5 → langgraph_api-0.11.0.dev6}/benchmark/continuous/pyproject.toml

@@ -4,10 +4,10 @@ version = "0.1.0"
 description = "Continuous stress test for Agent Server"
 requires-python = ">=3.13"
 dependencies = [
-    "langgraph-sdk>=0.3.13",
-    "click>=8.3.3",
+    "langgraph-sdk>=0.3.15",
+    "click>=8.4.1",
     "structlog>=24.1.0",
-    "datadog-api-client>=2.0.0",
+    "datadog-api-client>=2.55.0",
     "python-dateutil>=2.8.0",
     "httpx>=0.27.0",
 ]

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/benchmark/continuous/uv.lock

@@ -25,14 +25,14 @@ wheels = [
 
 [[package]]
 name = "click"
-version = "8.3.3"
+version = "8.4.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" },
 ]
 
 [[package]]
@@ -46,7 +46,7 @@ wheels = [
 
 [[package]]
 name = "datadog-api-client"
-version = "2.53.0"
+version = "2.55.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -54,9 +54,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/20/37/4f537b327906ff5fdf26531f2b3ec8994ffa41630d4bf1e130bb2cacb202/datadog_api_client-2.53.0.tar.gz", hash = "sha256:85e44f269d0a9757821a7af4ee35e324355a11ebe0efaabf6688efd9fa169d85", size = 4537088, upload-time = "2026-04-01T15:29:44.503Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/8d/6f7ddd04cc701cc590eab111a45e54c92158eddbff943ad4a1dbb5925b21/datadog_api_client-2.55.0.tar.gz", hash = "sha256:c56767c867a15b928da08d5c6077a7ac466e029a10a5045e80d79d76e92afaa3", size = 4994403, upload-time = "2026-05-15T17:20:06.825Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/a1/78ccb200fa3d037465cef14b0163005279757026429e76b5807e392dca1b/datadog_api_client-2.53.0-py3-none-any.whl", hash = "sha256:f965c10f846da03d3d1abe99f20331e42933c8736b7ee176f0a420ca019f1b17", size = 5925406, upload-time = "2026-04-01T15:29:41.128Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/28/9af04e1cccb57bc9754a5d4cd2fc5a006183e95b234336e9115fe95e5f12/datadog_api_client-2.55.0-py3-none-any.whl", hash = "sha256:fef8dcadbdcd1f7fbe89d97825cfc06c9a1e3577b61f04834b8d250c881d59a7", size = 6644614, upload-time = "2026-05-15T17:20:03.927Z" },
 ]
 
 [[package]]
@@ -120,25 +120,25 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "click", specifier = ">=8.3.3" },
-    { name = "datadog-api-client", specifier = ">=2.0.0" },
+    { name = "click", specifier = ">=8.4.1" },
+    { name = "datadog-api-client", specifier = ">=2.55.0" },
     { name = "httpx", specifier = ">=0.27.0" },
-    { name = "langgraph-sdk", specifier = ">=0.3.13" },
+    { name = "langgraph-sdk", specifier = ">=0.3.15" },
     { name = "python-dateutil", specifier = ">=2.8.0" },
     { name = "structlog", specifier = ">=24.1.0" },
 ]
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.3.14"
+version = "0.3.15"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
     { name = "orjson" },
 ]
-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" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/af/cdd4d6f3c05b3c1112ed3f12ef830faf15951b21d22cbc622a4becbbe25c/langgraph_sdk-0.3.15.tar.gz", hash = "sha256:29e805003d2c6e296823dd71992610976fd0428cefaa8b3304fd91f2247037de", size = 201924, upload-time = "2026-05-22T16:54:27.678Z" }
 wheels = [
-    { 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" },
+    { url = "https://files.pythonhosted.org/packages/be/a5/0196d9c05749c25bc198e4909d68c998bc3120297e14944921baf2f4c384/langgraph_sdk-0.3.15-py3-none-any.whl", hash = "sha256:3838773acf7456d158165385d49f48f1e856f28b56ccd99ea139a8f27004815d", size = 98166, upload-time = "2026-05-22T16:54:26.013Z" },
 ]
 
 [[package]]

langgraph_api-0.11.0.dev6/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.11.0.dev6"

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/event_streaming/session.py

@@ -698,25 +698,60 @@ class EventStreamingSession:
         if namespace:
             self._register_namespaces(namespace)
 
-        # Values events may carry pending interrupts on
-        # ``params.interrupts`` (upstream ValuesTransformer convention).
-        # Path 1 reads them from the ``__interrupt__`` key on the
-        # values payload; either way, surface them on the ``input``
-        # channel BEFORE the values snapshot so both paths produce the
-        # same ordering.
-        if method == "values":
+        data = params.get("data")
+
+        # Surface pending interrupts on the ``input`` channel. This branch
+        # exists for the JS sidecar (hybrid Python API + JS graph) path:
+        # the sidecar's v3 stream emits already-normalized ProtocolEvents
+        # that reach this handler, and it carries tool-raised interrupts
+        # (headless tools, human-in-the-loop) inline on ``updates`` /
+        # ``values`` events rather than on a dedicated channel. Without
+        # converting them into an ``input`` event here, the SDK renders the
+        # interrupting tool call but never learns the interrupt id, so it
+        # can't execute or resume the run. The carrier shape varies, so we
+        # accept all of them:
+        #   * ``params.interrupts`` — native ValuesTransformer convention.
+        #   * an ``updates`` event with ``node == "__interrupt__"`` whose
+        #     ``data.values`` is the interrupt array — the JS sidecar shape.
+        #   * the ``__interrupt__`` key on a ``values`` snapshot payload.
+        # ``_emit_input_requested_events`` dedupes by interrupt id, so
+        # overlapping shapes for one interrupt collapse to a single event.
+        if method == "updates":
+            update_node = params.get("node")
+            if not isinstance(update_node, str) and _is_record(data):
+                candidate = data.get("node")
+                update_node = candidate if isinstance(candidate, str) else None
+            if update_node == "__interrupt__":
+                interrupt_array = data.get("values") if _is_record(data) else None
+                await self._emit_input_requested_events(
+                    namespace, normalize_input_requested_data(interrupt_array)
+                )
+                # The ``__interrupt__`` update is purely the interrupt
+                # signal, not real state — it's consumed by the ``input``
+                # channel above and must not also be forwarded as a plain
+                # ``updates`` event.
+                return
+        elif method == "values":
+            # Always strip ``__interrupt__`` from the payload so it never
+            # leaks into the forwarded ``values`` event, regardless of
+            # which carrier the interrupt also rode in on. Surface
+            # interrupts from both carriers — ``_emit_input_requested_events``
+            # dedupes by interrupt id, so a single interrupt arriving on
+            # both collapses to one event.
+            input_requests, data = strip_interrupts_from_values(data)
             interrupts = params.get("interrupts")
             if isinstance(interrupts, (list, tuple)) and interrupts:
                 await self._emit_input_requested_events(
                     namespace, _coerce_interrupt_requests(interrupts)
                 )
+            if input_requests:
+                await self._emit_input_requested_events(namespace, input_requests)
 
         # Delegate envelope construction to the shared primitive. This
         # is the unified wire-shaping step; any envelope change lives
         # in ``_create_event`` and both paths follow.
         raw_timestamp = params.get("timestamp")
         timestamp = raw_timestamp if isinstance(raw_timestamp, int) else None
-        data = params.get("data")
 
         # Forward the producing graph node on the wire envelope to keep
         # Path 2 at parity with Path 1 (:meth:`_handle_source_event`).

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/grpc/ops/runs.py

@@ -130,6 +130,8 @@ STREAM_MODE_TO_PB = {
     "custom": enum_stream_mode.custom,
     "events": enum_stream_mode.events,
     "messages-tuple": enum_stream_mode.messages_tuple,
+    "tools": enum_stream_mode.tools,
+    "lifecycle": enum_stream_mode.lifecycle,
 }
 
 STREAM_MODE_FROM_PB = {

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/js/client.mts

@@ -383,9 +383,29 @@ const handleStream = <T extends z.ZodType<any>>(
   };
 };
 
+// Runtime-only callbacks must never cross the checkpoint boundary. The v3
+// stream injects a ``StreamProtocolMessagesHandler`` into ``config.callbacks``;
+// when that config is handed to the checkpointer it is sent to Python,
+// echoed back on the returned tuple's ``config`` / ``parent_config``, and
+// then fails ``load()`` because the handler serializes as a
+// ``not_implemented`` object (breaking branch / regenerate). The checkpointer
+// only needs ``configurable`` ids, so drop ``callbacks`` before sending.
+function stripConfigCallbacks(
+  config: RunnableConfig | undefined,
+): RunnableConfig | undefined {
+  if (config == null || typeof config !== "object" || !("callbacks" in config))
+    return config;
+  const { callbacks: _callbacks, ...rest } = config as RunnableConfig & {
+    callbacks?: unknown;
+  };
+  return rest;
+}
+
 class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
   async getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined> {
-    const result = await sendRecv("checkpointer_get_tuple", { config });
+    const result = await sendRecv("checkpointer_get_tuple", {
+      config: stripConfigCallbacks(config),
+    });
 
     if (!result) return undefined;
     return {
@@ -405,7 +425,13 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
       filter?: Record<string, any>;
     },
   ): AsyncGenerator<CheckpointTuple> {
-    const result = await sendRecv("checkpointer_list", { config, ...options });
+    const result = await sendRecv("checkpointer_list", {
+      config: stripConfigCallbacks(config),
+      ...options,
+      ...(options?.before
+        ? { before: stripConfigCallbacks(options.before) }
+        : {}),
+    });
 
     for (const item of result) {
       yield {
@@ -425,7 +451,7 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
     newVersions: ChannelVersions,
   ): Promise<RunnableConfig> {
     return await sendRecv<RunnableConfig>("checkpointer_put", {
-      config,
+      config: stripConfigCallbacks(config),
       checkpoint,
       metadata,
       new_versions: newVersions,
@@ -437,7 +463,11 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
     writes: [string, unknown][],
     taskId: string,
   ): Promise<void> {
-    await sendRecv("checkpointer_put_writes", { config, writes, taskId });
+    await sendRecv("checkpointer_put_writes", {
+      config: stripConfigCallbacks(config),
+      writes,
+      taskId,
+    });
   }
 
   getNextVersion(
@@ -617,6 +647,12 @@ const StreamEventsPayload = z.object({
   interrupt_before: z.union([z.array(z.string()), z.literal("*")]).nullish(),
   interrupt_after: z.union([z.array(z.string()), z.literal("*")]).nullish(),
   subgraphs: z.boolean().optional(),
+  // Selects the wire shape the worker expects back. ``"v3"`` is only sent
+  // by the Protocol v2 event-streaming endpoints and switches this handler
+  // onto LangGraphJS's native v3 stream (ProtocolEvents). Absent / ``"v2"``
+  // keeps the legacy ``on_chain_stream`` behavior used by the older
+  // streaming endpoints.
+  stream_protocol: z.enum(["v2", "v3"]).nullish(),
 });
 
 function reviveCommand(
@@ -713,6 +749,42 @@ async function* streamEventsRequest(
     ? [new LangChainTracer({ replicas })]
     : undefined;
 
+  // Protocol v2 event-streaming runs request ``stream_protocol: "v3"``.
+  // Drive the run through LangGraphJS's native v3 stream so its
+  // StreamMux / transformer pipeline emits protocol-aligned ProtocolEvents
+  // (messages content blocks, tools, custom:* channels, checkpoints)
+  // directly. The worker forwards these straight into
+  // ``EventStreamingSession`` — none of the legacy ``on_chain_stream``
+  // reconstruction below runs. The graph's own ``streamTransformers`` are
+  // merged in automatically by ``#streamEventsV3``, so custom channels work
+  // without any per-channel patching here. Legacy endpoints fall through to
+  // the unchanged ``version: "v2"`` path so their behavior is preserved.
+  if (payload.stream_protocol === "v3") {
+    // The v3 overload forces ``streamMode``/``subgraphs`` internally and
+    // returns an awaitable ``GraphRunStream`` of ProtocolEvents. Cast away
+    // the pinned ``CompiledGraph`` typing, which may predate the v3
+    // overload depending on the installed ``@langchain/langgraph``.
+    const protocolStream = await (
+      graph as unknown as {
+        streamEvents: (
+          input: unknown,
+          options: Record<string, unknown>,
+        ) => Promise<AsyncIterable<unknown>>;
+      }
+    ).streamEvents(input, {
+      ...config,
+      version: "v3",
+      interruptBefore,
+      interruptAfter,
+      ...(callbacks ? { callbacks } : {}),
+    });
+
+    for await (const event of protocolStream) {
+      yield event;
+    }
+    return;
+  }
+
   for await (const data of graph.streamEvents(input, {
     ...config,
     version: "v2",

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/js/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "@hono/node-server": "^1.19.13",
     "@hono/zod-validator": "^0.7.6",
-    "@langchain/core": "^1.1.38",
+    "@langchain/core": "^1.1.48",
     "@langchain/langgraph": "^1.2.6",
     "@langchain/langgraph-api": "^1.0.3",
     "@langchain/langgraph-checkpoint": "^1.0.0",
@@ -19,7 +19,7 @@
     "dedent": "^1.7.2",
     "esbuild": "^0.28.0",
     "exit-hook": "^5.1.0",
-    "hono": "^4.12.18",
+    "hono": "^4.12.21",
     "p-queue": "^9.0.1",
     "p-retry": "^7.1.1",
     "tsx": "^4.21.0",

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/js/remote.py

@@ -226,6 +226,36 @@ class RemotePregel(BaseRemotePregel):
             else:
                 yield StandardStreamEvent(**event)
 
+    async def astream_protocol_events(
+        self,
+        input: Any,
+        config: RunnableConfig | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Stream native Protocol v2 (``ProtocolEvent``) frames from the sidecar.
+
+        Used only for Protocol v2 event-streaming runs. Requests
+        ``stream_protocol: "v3"`` so the sidecar drives the graph through
+        LangGraphJS's native v3 stream and forwards protocol-aligned events
+        (``{"type": "event", "method", "params"}``) instead of legacy
+        ``on_chain_stream`` chunks. The worker feeds these straight into
+        ``EventStreamingSession`` via ``normalize_protocol_event``, matching
+        the native-graph v3 path. Legacy runs keep using
+        :meth:`astream_events` (``version="v2"``).
+        """
+        data = {
+            "graph_id": self.graph_id,
+            "graph_config": self.config,
+            "graph_name": self.name,
+            "command" if isinstance(input, Command) else "input": input,
+            "config": config,
+            "stream_protocol": "v3",
+            **kwargs,
+        }
+
+        async for event in _client_stream("streamEvents", data):
+            yield event
+
     async def fetch_state_schema(self):
         return await _client_invoke("getSchema", {"graph_id": self.graph_id})
 

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/js/yarn.lock

@@ -241,21 +241,17 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
-"@langchain/core@^1.1.38":
-  version "1.1.38"
-  resolved "https://registry.npmjs.org/@langchain/core/-/core-1.1.38.tgz"
-  integrity sha512-C340wH1YL10CiVOFlEpQMp0zQE85/eBLKX/gi1Lv7shAyUmR3CQ0t/mXlCd5RsZa6ntAN1kDJnp64ArWey9XAA==
+"@langchain/core@^1.1.48":
+  version "1.1.48"
+  resolved "https://registry.yarnpkg.com/@langchain/core/-/core-1.1.48.tgz#dfe7f6a64b0e3e79e5357ed4b402c021ee315a7f"
+  integrity sha512-fQU6Guyb1pwc2fEplmA8FPbKfOMAofjnyJzExevro0FxEiuGHE18Ov/ZHmT9trWCDTZRI9eW1VIc6aChxV8pAQ==
   dependencies:
     "@cfworker/json-schema" "^4.0.2"
     "@standard-schema/spec" "^1.1.0"
-    ansi-styles "^5.0.0"
-    camelcase "6"
-    decamelize "1.2.0"
     js-tiktoken "^1.0.12"
     langsmith ">=0.5.0 <1.0.0"
     mustache "^4.2.0"
     p-queue "^6.6.2"
-    uuid "^11.1.0"
     zod "^3.25.76 || ^4"
 
 "@langchain/langgraph-api@^1.0.3":
@@ -833,11 +829,6 @@
     convert-source-map "^2.0.0"
     tinyrainbow "^3.1.0"
 
-ansi-styles@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz"
-  integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
-
 assertion-error@^2.0.1:
   version "2.0.1"
   resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz"
@@ -887,11 +878,6 @@ bundle-name@^4.1.0:
   dependencies:
     run-applescript "^7.0.0"
 
-camelcase@6:
-  version "6.3.0"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz"
-  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
-
 caniuse-lite@^1.0.30001759, caniuse-lite@^1.0.30001766:
   version "1.0.30001770"
   resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001770.tgz"
@@ -968,11 +954,6 @@ debug@^4.4.3:
   dependencies:
     ms "^2.1.3"
 
-decamelize@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz"
-  integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
-
 dedent@^1.5.3, dedent@^1.7.2:
   version "1.7.2"
   resolved "https://registry.npmjs.org/dedent/-/dedent-1.7.2.tgz"
@@ -1152,10 +1133,10 @@ graceful-fs@^4.2.4:
   resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
   integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
 
-hono@^4.12.18, hono@^4.5.4:
-  version "4.12.18"
-  resolved "https://registry.yarnpkg.com/hono/-/hono-4.12.18.tgz#f6d301938868c3a8bdb639495f4e326a19181505"
-  integrity sha512-RWzP96k/yv0PQfyXnWjs6zot20TqfpfsNXhOnev8d1InAxubW93L11/oNUc3tQqn2G0bSdAOBpX+2uDFHV7kdQ==
+hono@^4.12.21, hono@^4.5.4:
+  version "4.12.21"
+  resolved "https://registry.yarnpkg.com/hono/-/hono-4.12.21.tgz#f11846462095d365b9a8b4859b37c02cb0981df3"
+  integrity sha512-uV63apnb0kyPtAUwoWgaGh9HyIFcv8lgmzPZSiTBQAFOFGIzka5EZ1dZocmGnn0XdX0+XTqJ6Tqv7selMuGLRQ==
 
 icss-utils@^5.0.0, icss-utils@^5.1.0:
   version "5.1.0"
@@ -1776,11 +1757,6 @@ uuid@^10.0.0:
   resolved "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz"
   integrity sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==
 
-uuid@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz"
-  integrity sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==
-
 uuid@^13.0.0:
   version "13.0.0"
   resolved "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz"

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/stream.py

@@ -53,7 +53,11 @@ from langgraph_api.metrics_otlp import (
 )
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
-from langgraph_api.stream_v2 import astream_state_v2, is_v2_messages_chunk
+from langgraph_api.stream_v2 import (
+    astream_state_v2,
+    is_v2_messages_chunk,
+    normalize_protocol_event,
+)
 from langgraph_api.utils.config import run_in_executor
 
 if TYPE_CHECKING:
@@ -200,6 +204,9 @@ async def astream_state(
     if cmd := kwargs.pop("command"):
         input = map_cmd(cmd)
     stream_mode: list[StreamMode] = kwargs.pop("stream_mode")
+    # Go maps unrecognized ``StreamMode`` enum values to ``unknown``; the
+    # round-trip converts those to ``None``.
+    stream_mode = [mode for mode in stream_mode if mode is not None]
     feedback_keys = kwargs.pop("feedback_keys", None)
     stream_modes_set: set[StreamMode] = set(stream_mode) - {"events"}
     # This code path runs for every run, legacy and v2. The per-run
@@ -254,7 +261,20 @@ async def astream_state(
     # set up state
     checkpoint: CheckpointPayload | None = None
     messages: dict[str, BaseMessageChunk] = {}
-    use_astream_events = "events" in stream_mode or is_remote_pregel
+    # Protocol v2 runs against a remote (JS sidecar) graph drive the sidecar
+    # through LangGraphJS's native v3 stream (``stream_protocol: "v3"``) so
+    # protocol-aligned events (messages content blocks, tools, custom:*,
+    # checkpoints) arrive ready to forward — no legacy ``on_chain_stream``
+    # reconstruction. ``hasattr`` keeps any other ``BaseRemotePregel`` impl on
+    # the legacy path. Legacy stream endpoints keep ``version="v2"``.
+    use_remote_v3 = (
+        event_streaming_v2_run
+        and is_remote_pregel
+        and hasattr(graph, "astream_protocol_events")
+    )
+    use_astream_events = (
+        "events" in stream_mode or is_remote_pregel
+    ) and not use_remote_v3
     use_stream_events_v3 = (
         event_streaming_v2_run and not use_astream_events and not is_remote_pregel
     )
@@ -429,6 +449,37 @@ async def astream_state(
             on_task_result=on_task_result,
         ):
             yield ev
+    elif use_remote_v3:
+        # Remote (JS) graph under Protocol v2: consume native v3
+        # ProtocolEvents from the sidecar and forward them exactly like the
+        # native-graph v3 path (``astream_state_v2``) does, so the
+        # ``EventStreamingSession`` normalization is identical regardless of
+        # graph language.
+        if USE_RUNTIME_CONTEXT_API:
+            kwargs["context"] = context
+        async with (
+            stack,
+            aclosing(
+                graph.astream_protocol_events(
+                    input,
+                    config,
+                    stream_mode=list(stream_modes_set),
+                    **kwargs,
+                )
+            ) as stream,
+        ):
+            sentinel = object()
+            while True:
+                event = await wait_if_not_done(anext(stream, sentinel), done)
+                if event is sentinel:
+                    break
+                normalized = normalize_protocol_event(
+                    cast("dict", event),
+                    on_checkpoint=on_checkpoint,
+                    on_task_result=on_task_result,
+                )
+                if normalized is not None:
+                    yield normalized
     else:
         output_keys = kwargs.pop("output_keys", graph.output_channels)
         if USE_RUNTIME_CONTEXT_API:

{langgraph_api-0.11.0.dev5 → langgraph_api-0.11.0.dev6}/langgraph_api/stream_v2.py

@@ -87,6 +87,59 @@ def coerce_stream_transformer_factory(
     )
 
 
+def normalize_protocol_event(
+    event: Any,
+    *,
+    on_checkpoint: Callable[[CheckpointPayload | None], None],
+    on_task_result: Callable[[TaskResultPayload], None],
+) -> tuple[str, dict] | None:
+    """Convert one native v3 ``ProtocolEvent`` into a ``(name, event)`` pair.
+
+    Shared by the native-graph path (``astream_state_v2``) and the remote
+    (JS sidecar) path in :mod:`langgraph_api.stream`. Both receive the same
+    ``{"type": "event", "method", "params"}`` ProtocolEvent shape — for
+    native graphs from ``langgraph``'s v3 stream, for remote graphs from the
+    sidecar's ``streamEvents`` v3 mode — so the per-event handling lives in
+    one place.
+
+    Returns ``None`` when the event should be dropped (e.g. a legacy
+    ``messages`` shape that Protocol v2 does not reconstruct). Side effects:
+    feeds checkpoint / task_result frames into ``on_checkpoint`` /
+    ``on_task_result`` so retention + persistence hooks still fire under v2.
+    """
+    # Local import to avoid a circular ``stream <-> stream_v2`` cycle.
+    from langgraph_api.stream import _preprocess_debug_checkpoint  # noqa: PLC0415
+
+    event = cast("dict", event)
+    method = event.get("method", "")
+    params = event.get("params") or {}
+    namespace = params.get("namespace") or []
+    if method == "debug":
+        chunk = params.get("data") or {}
+        if isinstance(chunk, dict):
+            if chunk.get("type") == "checkpoint":
+                checkpoint = _preprocess_debug_checkpoint(chunk.get("payload"))
+                chunk["payload"] = checkpoint
+                on_checkpoint(checkpoint)
+            elif chunk.get("type") == "task_result":
+                on_task_result(chunk.get("payload"))
+    # Protocol v2 only forwards native content-block-shaped messages;
+    # legacy whole-message/chunk tuples are for the old endpoints and are
+    # intentionally ignored here.
+    if method == "messages":
+        raw_data = params.get("data")
+        payload = normalize_v2_messages_data(raw_data)
+        if payload is None:
+            return None
+        if payload is not raw_data:
+            params = {**params, "data": payload}
+            event = {**event, "params": params}
+    # Carry the namespace in the stream event name so ``parse_event_name``
+    # in ``session.py`` can recover it, matching the raw ``astream`` path.
+    ns_suffix = f"|{'|'.join(namespace)}" if namespace else ""
+    return f"{method}{ns_suffix}", event
+
+
 def is_v2_messages_chunk(chunk: Any) -> bool:
     """Heuristically detect a ``StreamMessagesHandlerV2`` chunk.
 
@@ -131,10 +184,9 @@ async def astream_state_v2(
         StreamTransformer,
     )
 
-    # Local imports to avoid a circular ``stream <-> stream_v2`` cycle and
+    # Local import to avoid a circular ``stream <-> stream_v2`` cycle and
     # keep this module's import graph small.
     from langgraph_api.graph import GRAPH_STREAM_TRANSFORMERS  # noqa: PLC0415
-    from langgraph_api.stream import _preprocess_debug_checkpoint  # noqa: PLC0415
 
     user_transformers: list[Any] | None = None
     factory = GRAPH_STREAM_TRANSFORMERS.get(configurable.get("graph_id"))
@@ -191,34 +243,10 @@ async def astream_state_v2(
             event = await wait_if_not_done(anext(iterator, sentinel), done)
             if event is sentinel:
                 break
-            event = cast("dict", event)
-            method = event.get("method", "")
-            params = event.get("params") or {}
-            namespace = params.get("namespace") or []
-            # Feed checkpoint / task_result into the run state machine
-            # so retention + persistence hooks still fire under v2.
-            if method == "debug":
-                chunk = params.get("data") or {}
-                if isinstance(chunk, dict):
-                    if chunk.get("type") == "checkpoint":
-                        checkpoint = _preprocess_debug_checkpoint(chunk.get("payload"))
-                        chunk["payload"] = checkpoint
-                        on_checkpoint(checkpoint)
-                    elif chunk.get("type") == "task_result":
-                        on_task_result(chunk.get("payload"))
-            # Protocol v2 only forwards native content-block-shaped
-            # messages; legacy whole-message/chunk tuples are for the
-            # old endpoints and are intentionally ignored here.
-            if method == "messages":
-                raw_data = params.get("data")
-                payload = normalize_v2_messages_data(raw_data)
-                if payload is None:
-                    continue
-                if payload is not raw_data:
-                    params = {**params, "data": payload}
-                    event = {**event, "params": params}
-            # Carry the namespace in the stream event name so
-            # ``parse_event_name`` in ``session.py`` can recover it,
-            # matching the raw ``astream`` path.
-            ns_suffix = f"|{'|'.join(namespace)}" if namespace else ""
-            yield f"{method}{ns_suffix}", event
+            normalized = normalize_protocol_event(
+                event,
+                on_checkpoint=on_checkpoint,
+                on_task_result=on_task_result,
+            )
+            if normalized is not None:
+                yield normalized