docs: fix langgraph dataplane docs to remove license key

This was lost when the v0 branch was cut out and docs started being deployed from v0

.github/workflows/_test_release.yml

@@ -13,7 +13,7 @@ env:
 
 jobs:
   build:
-    if: github.ref == 'refs/heads/main'
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v0'
     runs-on: ubuntu-latest
 
     outputs:

.github/workflows/deploy_docs.yml

@@ -4,9 +4,11 @@ on:
   push:
     branches:
       - main
+      - v0
   pull_request:
     branches:
       - main
+      - v0
   workflow_dispatch:
 
 permissions:
@@ -82,9 +84,9 @@ jobs:
         run: make llms-text
       - name: Build site
         run: |
-          # If this is main branch, then we want to download stats. we do this 
+          # If this is v0 branch, then we want to download stats. we do this 
           # with the env variable DOWNLOAD_STATS=true
-          if [ "${{ github.ref }}" == "refs/heads/main" ]; then
+          if [ "${{ github.ref }}" == "refs/heads/v0" ]; then
             DOWNLOAD_STATS=true make build-docs
           else
             make build-docs
@@ -144,8 +146,8 @@ jobs:
           fi
 
       - name: Configure GitHub Pages
-        if: github.ref == 'refs/heads/main'
-        uses: actions/configure-pages@v4
+        if: github.ref == 'refs/heads/v0'
+        uses: actions/configure-pages@v5
 
       - name: Upload Pages Artifact
         # if: github.ref == 'refs/heads/main'
@@ -154,6 +156,6 @@ jobs:
           path: ./docs/site/
 
       - name: Deploy to GitHub Pages
-        if: github.ref == 'refs/heads/main'
+        if: github.ref == 'refs/heads/v0'
         id: deployment
         uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -13,7 +13,7 @@ env:
 
 jobs:
   build:
-    if: github.ref == 'refs/heads/main'
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v0'
     runs-on: ubuntu-latest
 
     outputs:

README.md

@@ -74,7 +74,7 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L
 
 - [Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
 - [Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
-- [Examples](https://langchain-ai.github.io/langgraph/tutorials/): Guided examples on getting started with LangGraph.
+- [Examples](https://langchain-ai.github.io/langgraph/tutorials/overview/): Guided examples on getting started with LangGraph.
 - [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
 - [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
 - [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.

docs/_scripts/notebook_hooks.py

@@ -1,9 +1,16 @@
+"""mkdocs hooks for adding custom logic to documentation pipeline.
+
+Lifecycle events: https://www.mkdocs.org/dev-guide/plugins/#events
+"""
+
 import logging
 import os
 import posixpath
 import re
 from typing import Any, Dict
 
+from bs4 import BeautifulSoup
+from mkdocs.config.defaults import MkDocsConfig
 from mkdocs.structure.files import Files, File
 from mkdocs.structure.pages import Page
 
@@ -101,8 +108,7 @@ REDIRECT_MAP = {
     "how-tos/deploy-self-hosted.md": "cloud/deployment/self_hosted_data_plane.md",
     "concepts/self_hosted.md": "concepts/langgraph_self_hosted_data_plane.md",
     # assistant redirects
-    "cloud/how-tos/assistant_versioning.md": "cloud/how-tos/configuration_cloud.md"
-
+    "cloud/how-tos/assistant_versioning.md": "cloud/how-tos/configuration_cloud.md",
 }
 
 
@@ -292,7 +298,7 @@ Redirecting...
 """
 
 
-def write_html(site_dir, old_path, new_path):
+def _write_html(site_dir, old_path, new_path):
     """Write an HTML file in the site_dir with a meta redirect to the new page"""
     # Determine all relevant paths
     old_path_abs = os.path.join(site_dir, old_path)
@@ -308,6 +314,52 @@ def write_html(site_dir, old_path, new_path):
         f.write(content)
 
 
+def _inject_gtm(html: str) -> str:
+    """Inject Google Tag Manager code into the HTML.
+
+    Code to inject Google Tag Manager noscript tag immediately after <body>.
+
+    This is done via hooks rather than via a template because the MkDocs material
+    theme does not seem to allow placing the code immediately after the <body> tag
+    without modifying the template files directly.
+
+    Args:
+        html: The HTML content to modify.
+
+    Returns:
+        The modified HTML content with GTM code injected.
+    """
+    # Code was copied from Google Tag Manager setup instructions.
+    gtm_code = """
+<!-- Google Tag Manager (noscript) -->
+<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-T35S4S46"
+height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
+<!-- End Google Tag Manager (noscript) -->
+"""
+    soup = BeautifulSoup(html, "html.parser")
+    body = soup.body
+    if body:
+        # Insert the GTM code as raw HTML at the top of <body>
+        body.insert(0, BeautifulSoup(gtm_code, "html.parser"))
+        return str(soup)
+    else:
+        return html  # fallback if no <body> found
+
+
+def on_post_page(output: str, page: Page, config: MkDocsConfig) -> str:
+    """Inject Google Tag Manager noscript tag immediately after <body>.
+
+    Args:
+        output: The HTML output of the page.
+        page: The page instance.
+        config: The MkDocs configuration object.
+
+    Returns:
+        modified HTML output with GTM code injected.
+    """
+    return _inject_gtm(output)
+
+
 # Create HTML files for redirects after site dir has been built
 def on_post_build(config):
     use_directory_urls = config.get("use_directory_urls")
@@ -324,4 +376,4 @@ def on_post_build(config):
             + hash
             + suffix
         )
-        write_html(config["site_dir"], old_html_path, new_html_path)
+        _write_html(config["site_dir"], old_html_path, new_html_path)

docs/docs/agents/agents.md

@@ -15,7 +15,7 @@ This guide shows you how to set up and use LangGraph's **prebuilt**, **reusable*
 
 Before you start this tutorial, ensure you have the following:
 
-- An [Anthropic](https://console.anthropic.com/settings/admin-keys) API key 
+- An [Anthropic](https://console.anthropic.com/settings/keys) API key 
 
 ## 1. Install dependencies
 

docs/docs/agents/memory.md

@@ -82,7 +82,7 @@ ny_response = agent.invoke(
 ```
 
 1. The `InMemorySaver` is a checkpointer that stores the agent's state in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [checkpointer documentation](../reference/checkpoints.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready checkpointer for you.
-2. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations. Please note that 
+2. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations.
 3. A unique `thread_id` is provided in the config. This ID is used to identify the conversation session. The value is controlled by the user and can be any string.
 4. The agent will continue the conversation using the same `thread_id`. This will allow the agent to infer that the user is asking specifically about the **weather** in New York. 
 

docs/docs/cloud/deployment/self_hosted_data_plane.md

@@ -31,7 +31,6 @@ Before deploying, review the [conceptual guide for the Self-Hosted Data Plane](.
 1. Configure your `langgraph-dataplane-values.yaml` file.
 
         config:
-          langgraphPlatformLicenseKey: "" # Your LangGraph Platform license key
           langsmithApiKey: "" # API Key of your Workspace
           langsmithWorkspaceId: "" # Workspace ID
           hostBackendUrl: "https://api.host.langchain.com" # Only override this if on EU

docs/docs/cloud/reference/cli.md

@@ -43,6 +43,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and returns an instance of `langgraph.graph.state.StateGraph` or `langgraph.graph.state.CompiledStateGraph`. See [how to rebuild a graph at runtime](../../cloud/deployment/graph_rebuild.md) for more details.</li></ul>                                    |
     | <span style="white-space: nowrap;">`auth`</span>             | _(Added in v0.0.11)_ Auth configuration containing the path to your authentication handler. Example: `./your_package/auth.py:auth`, where `auth` is an instance of `langgraph_sdk.Auth`. See [authentication guide](../../concepts/auth.md) for details.                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`base_image`</span>       | Optional. Base image to use for the LangGraph API server. Defaults to `langchain/langgraph-api` or `langchain/langgraphjs-api`. Use this to pin your builds to a particular version of the langgraph API, such as `"langchain/langgraph-server:0.2"`. See https://hub.docker.com/r/langchain/langgraph-server/tags for more details. (added in `langgraph-cli==0.2.8`) |
+    | <span style="white-space: nowrap;">`image_distro`</span>     | Optional. Linux distribution for the base image. Must be either `"debian"` or `"wolfi"`. If omitted, defaults to `"debian"`. Available in `langgraph-cli>=0.2.11`.|
     | <span style="white-space: nowrap;">`env`</span>              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`store`</span>            | Configuration for adding semantic search and/or time-to-live (TTL) to the BaseStore. Contains the following fields: <ul><li>`index` (optional): Configuration for semantic search indexing with fields `embed`, `dims`, and optional `fields`.</li><li>`ttl` (optional): Configuration for item expiration. An object with optional fields: `refresh_on_read` (boolean, defaults to `true`), `default_ttl` (float, lifespan in **minutes**, defaults to no expiration), and `sweep_interval_minutes` (integer, how often to check for expired items, defaults to no sweeping).</li></ul> |
     | <span style="white-space: nowrap;">`ui`</span>               | Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file. (added in `langgraph-cli==0.1.84`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -79,6 +80,20 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     }
     ```
 
+    #### Using Wolfi Base Images
+
+    You can specify the Linux distribution for your base image using the `image_distro` field. Valid options are `debian` or `wolfi`. Wolfi is the recommended option as it provides smaller and more secure images. This is available in `langgraph-cli>=0.2.11`.
+
+    ```json
+    {
+      "dependencies": ["."],
+      "graphs": {
+        "chat": "./chat/graph.py:graph"
+      },
+      "image_distro": "wolfi"
+    }
+    ```
+
     #### Adding semantic search to the store
 
     All deployments come with a DB-backed BaseStore. Adding an "index" configuration to your `langgraph.json` will enable [semantic search](../deployment/semantic_search.md) within the BaseStore of your deployment.

docs/docs/cloud/reference/env_var.md

@@ -123,3 +123,12 @@ Defaults to `''`.
 Set `REDIS_CLUSTER` to `True` to enable Redis Cluster mode. When enabled, the system will connect to Redis using cluster mode. This is useful when connecting to a Redis Cluster deployment.
 
 Defaults to `False`.
+
+## `MOUNT_PREFIX`
+
+!!! info "Only Allowed in Self-Hosted Deployments"
+    The `MOUNT_PREFIX` environment variable is only allowed in Self-Hosted Deployment models, LangGraph Platform SaaS will not allow this environment variable.
+
+Set `MOUNT_PREFIX` to serve the LangGraph Server under a specific path prefix. This is useful for deployments where the server is behind a reverse proxy or load balancer that requires a specific path prefix.
+
+For example, if the server is to be served under `https://example.com/langgraph`, set `MOUNT_PREFIX` to `/langgraph`.

docs/docs/concepts/low_level.md

@@ -197,19 +197,25 @@ In LangGraph, nodes are typically python functions (sync or async) where the **f
 Similar to `NetworkX`, you add these nodes to a graph using the [add_node][langgraph.graph.StateGraph.add_node] method:
 
 ```python
+from typing_extensions import TypedDict
+
 from langchain_core.runnables import RunnableConfig
 from langgraph.graph import StateGraph
 
-builder = StateGraph(dict)
+class State(TypedDict):
+    input: str
+    results: str
+
+builder = StateGraph(State)
 
 
-def my_node(state: dict, config: RunnableConfig):
+def my_node(state: State, config: RunnableConfig):
     print("In node: ", config["configurable"]["user_id"])
     return {"results": f"Hello, {state['input']}!"}
 
 
 # The second argument is optional
-def my_other_node(state: dict):
+def my_other_node(state: State):
     return state
 
 

docs/docs/concepts/persistence.md

@@ -470,9 +470,34 @@ If the checkpointer is used with asynchronous graph execution (i.e. executing th
 
 ### Serializer
 
-When checkpointers save the graph state, they need to serialize the channel values in the state. This is done using serializer objects. 
+When checkpointers save the graph state, they need to serialize the channel values in the state. This is done using serializer objects.
 `langgraph_checkpoint` defines [protocol][langgraph.checkpoint.serde.base.SerializerProtocol] for implementing serializers provides a default implementation ([JsonPlusSerializer][langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer]) that handles a wide variety of types, including LangChain and LangGraph primitives, datetimes, enums and more.
 
+#### Encryption
+
+Checkpointers can optionally encrypt all persisted state. To enable this, pass an instance of [`EncryptedSerializer`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer] to the `serde` argument of any `BaseCheckpointSaver` implementation. The easiest way to create an encrypted serializer is via [`from_pycryptodome_aes`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer.from_pycryptodome_aes], which reads the AES key from the `LANGGRAPH_AES_KEY` environment variable (or accepts a `key` argument):
+
+```python
+import sqlite3
+
+from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
+from langgraph.checkpoint.sqlite import SqliteSaver
+
+serde = EncryptedSerializer.from_pycryptodome_aes()  # reads LANGGRAPH_AES_KEY
+checkpointer = SqliteSaver(sqlite3.connect("checkpoint.db"), serde=serde)
+```
+
+```python
+from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
+from langgraph.checkpoint.postgres import PostgresSaver
+
+serde = EncryptedSerializer.from_pycryptodome_aes()
+checkpointer = PostgresSaver.from_conn_string("postgresql://...", serde=serde)
+checkpointer.setup()
+```
+
+When running on LangGraph Platform, encryption is automatically enabled whenever `LANGGRAPH_AES_KEY` is present, so you only need to provide the environment variable. Other encryption schemes can be used by implementing [`CipherProtocol`][langgraph.checkpoint.serde.base.CipherProtocol] and supplying it to `EncryptedSerializer`.
+
 ## Capabilities
 
 ### Human-in-the-loop

docs/docs/how-tos/graph-api.ipynb

@@ -2235,7 +2235,7 @@
     "    if termination_condition(state):\n",
     "        return END\n",
     "    else:\n",
-    "        return \"a\"\n",
+    "        return \"b\"\n",
     "\n",
     "builder.add_edge(START, \"a\")\n",
     "builder.add_conditional_edges(\"a\", route)\n",
@@ -2950,16 +2950,6 @@
     "    When you send updates from a subgraph node to a parent graph node for a key that's shared by both parent and subgraph [state schemas](../../concepts/low_level#schema), you **must** define a [reducer](../../concepts/low_level#reducers) for the key you're updating in the parent graph state. See the example below."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "6be0aeb9-e138-4adc-a1df-5d743a8eb348",
-   "metadata": {},
-   "source": [
-    "!!! important \"State updates with `Command.PARENT`\"\n",
-    "\n",
-    "    When you send updates from a subgraph node to a parent graph node for a key that's shared by both parent and subgraph [state schemas](../../concepts/low_level#schema), you **must** define a [reducer](../../concepts/low_level#reducers) for the key you're updating in the parent graph state."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 6,

docs/docs/reference/checkpoints.md

@@ -12,12 +12,18 @@
     options:
       members:
         - SerializerProtocol
+        - CipherProtocol
 
 ::: langgraph.checkpoint.serde.jsonplus
     options:
       members:
         - JsonPlusSerializer
 
+::: langgraph.checkpoint.serde.encrypted
+    options:
+      members:
+        - EncryptedSerializer
+
 ::: langgraph.checkpoint.memory
 
 ::: langgraph.checkpoint.sqlite
@@ -32,4 +38,4 @@
 ::: langgraph.checkpoint.postgres.aio
     options:
       members:
-        - AsyncPostgresSaver
+        - AsyncPostgresSaver

docs/docs/tutorials/get-started/1-build-basic-chatbot.md

@@ -6,7 +6,7 @@ In this tutorial, you will build a basic chatbot. This chatbot is the basis for
 
 Before you start this tutorial, ensure you have access to a LLM that supports
 tool-calling features, such as [OpenAI](https://platform.openai.com/api-keys),
-[Anthropic](https://console.anthropic.com/settings/admin-keys), or
+[Anthropic](https://console.anthropic.com/settings/keys), or
 [Google Gemini](https://ai.google.dev/gemini-api/docs/api-key).
 
 ## 1. Install packages

docs/docs/tutorials/get-started/2-add-tools.md

@@ -146,7 +146,7 @@ graph_builder.add_node("tools", tool_node)
 
 !!! note
 
-    If you do not want to build this yourself in the future, you can use LangGraph's prebuilt [ToolNode](https://langchain-ai.github.io/langgraph/reference/prebuilt/#toolnode).
+    If you do not want to build this yourself in the future, you can use LangGraph's prebuilt [ToolNode](https://langchain-ai.github.io/langgraph/reference/agents/#langgraph.prebuilt.tool_node.ToolNode).
 
 ## 6. Define the `conditional_edges`
 

docs/docs/tutorials/overview.md

@@ -0,0 +1,21 @@
+# Examples
+
+The pages in this section provide end-to-end examples for the following topics:
+
+## General 
+
+- [Agentic RAG](./rag/langgraph_adaptive_rag.ipynb)
+- [Agent Supervisor](./multi_agent/agent_supervisor.ipynb)
+- [SQL agent](./sql-agent.ipynb)
+- [Graph runs in LangSmith](../how-tos/run-id-langsmith.ipynb)
+
+## LangGraph Platform
+
+- [Set up custom authentication](./auth/getting_started.md)
+- [Make conversations private](./auth/resource_auth.md)
+- [Connect an authentication provider](./auth/add_auth_server.md)
+- [Rebuild graph at runtime](../cloud/deployment/graph_rebuild.md)
+- [Use RemoteGraph](../how-tos/use-remote-graph.md)
+- [Deploy CrewAI, AutoGen, and other frameworks](../how-tos/autogen-langgraph-platform.ipynb)
+- [Integrate LangGraph into a React app](../cloud/how-tos/use_stream_react.md)
+- [Implement Generative User Interfaces with LangGraph](../cloud/how-tos/generative_ui_react.md)

docs/mkdocs.yml

@@ -381,25 +381,6 @@ extra:
       link: https://github.com/langchain-ai/langgraph
     - icon: fontawesome/brands/twitter
       link: https://twitter.com/LangChainAI
-  analytics:
-    provider: google
-    property: G-G8X6ELZYE0
-    feedback:
-      title: Was this page helpful?
-      ratings:
-        - icon: material/emoticon-happy-outline
-          name: This page was helpful
-          data: 1
-          note: >-
-            Thanks for your feedback!
-        - icon: material/emoticon-sad-outline
-          name: This page could be improved
-          data: 0
-          note: >-
-            Thanks for your feedback! Please help us improve this page by adding to the discussion below.
-  shared_analytics:
-    provider: google
-    property: G-47WX3HKKY2
 validation:
   # https://www.mkdocs.org/user-guide/configuration/
   # We are still raising for omitted files because they determine the breadcrumbs for pages.

docs/overrides/main.html

@@ -1,5 +1,16 @@
 {% extends "base.html" %}
 
+{% block analytics %}
+<!-- Google Tag Manager -->
+<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+})(window,document,'script','dataLayer','GTM-T35S4S46');</script>
+<!-- End Google Tag Manager -->
+{% endblock %}
+
+
 {% block extrahead %}
   <meta name="algolia-site-verification" content="165B7E7C89E49946" />
   <style>
@@ -185,7 +196,6 @@
   </style>
 {% endblock %}
 
-
 {% block content %}
 <div class="notebook-links">
   {% if page.nb_url %}
@@ -209,7 +219,6 @@
   {% endif %}
 {% endblock %}
 
-
 {% block announce %}
 <strong>We are growing and hiring for multiple roles for LangChain, LangGraph and LangSmith. <a href="https://www.langchain.com/careers" target="_blank" rel="noopener noreferrer"> Join our team!</a></strong>
 {% endblock %}

docs/uv.lock

@@ -2590,7 +2590,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.4.5"
+version = "0.4.7"
 source = { editable = "../libs/langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -2891,7 +2891,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "../libs/prebuilt" }
 dependencies = [
     { name = "langchain-core" },

libs/langgraph/README.md

@@ -74,7 +74,7 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L
 
 - [Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
 - [Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
-- [Examples](https://langchain-ai.github.io/langgraph/tutorials/): Guided examples on getting started with LangGraph.
+- [Examples](https://langchain-ai.github.io/langgraph/tutorials/overview/): Guided examples on getting started with LangGraph.
 - [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
 - [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
 - [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.

libs/langgraph/langgraph/graph/schema_utils.py

@@ -1,268 +0,0 @@
-import functools
-import logging
-import weakref
-from dataclasses import is_dataclass
-from inspect import isclass
-from typing import (
-    Annotated,
-    Any,
-    Callable,
-    Optional,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
-
-from pydantic import BaseModel, ConfigDict, TypeAdapter
-from typing_extensions import is_typeddict
-
-__all__ = ["SchemaCoercionMapper"]
-
-logger = logging.getLogger(__name__)
-
-
-_cache: weakref.WeakKeyDictionary[type[Any], dict[int, "SchemaCoercionMapper"]] = (
-    weakref.WeakKeyDictionary()
-)
-
-
-class SchemaCoercionMapper:
-    """Lightweight coercion of *dict* → *BaseModel* instances."""
-
-    def __new__(
-        cls,
-        schema: type[Any],
-        type_hints: Optional[dict[str, Any]] = None,
-        *,
-        max_depth: int = 12,
-    ) -> "SchemaCoercionMapper":
-        by_depth = _cache.setdefault(schema, {})
-        if max_depth in by_depth:
-            return by_depth[max_depth]
-        inst = super().__new__(cls)
-        by_depth[max_depth] = inst
-        return inst
-
-    def __init__(
-        self,
-        schema: type[BaseModel],
-        type_hints: Optional[dict[str, Any]] = None,
-        *,
-        max_depth: int = 12,
-    ) -> None:
-        if hasattr(self, "_initialised"):
-            return
-        self._initialised = True
-
-        self.schema = schema
-        self.max_depth = max_depth
-
-        self.type_hints = (
-            type_hints
-            if type_hints is not None
-            else get_type_hints(schema, localns={schema.__name__: schema})
-        )
-
-        if issubclass(schema, BaseModel):
-            self._fields = {
-                n: self.type_hints.get(n, f.annotation)
-                for n, f in schema.model_fields.items()
-            }
-            self._construct: Callable[..., Any] = schema.model_construct
-            unhandled_attrs = ("validators", "field_validators", "root_validators")
-            if (decorators := getattr(schema, "__pydantic_decorators__", None)) and any(
-                getattr(decorators, attr, None) for attr in unhandled_attrs
-            ):
-                self.coerce = lambda v, _: schema.model_validate(v)
-            else:
-                self.coerce = self._coerce
-        else:
-            raise TypeError("Schema must be a Pydantic V2 model.")
-
-        self._field_coercers: Optional[dict[str, Callable[[Any, int], Any]]] = None
-
-    def __call__(self, input_data: Any, depth: Optional[int] = None) -> Any:
-        return self.coerce(input_data, depth)
-
-    def _coerce(self, input_data: Any, depth: Optional[int] = None) -> Any:
-        if depth is None:
-            depth = self.max_depth
-        if not isinstance(input_data, dict) or depth <= 0:
-            return input_data
-
-        if self._field_coercers is None:
-            self._field_coercers = {
-                n: self._build_coercer(t, depth - 1) for n, t in self._fields.items()
-            }
-
-        processed: dict[str, Any] = {}
-        for k, v in input_data.items():
-            fn = self._field_coercers.get(k)
-            processed[k] = fn(v, depth - 1) if fn else v
-        return self._construct(**processed)
-
-    def _build_coercer(
-        self, field_type: Any, depth: int, *, throw: bool = False
-    ) -> Callable[[Any, Any], Any]:
-        if depth == 0:
-            return self._passthrough
-
-        origin = get_origin(field_type)
-
-        if (field_type in _IDENTITY_TYPES) or (origin in _IDENTITY_TYPES):
-            return self._passthrough
-
-        if origin is Annotated:
-            real_type, *_ = get_args(field_type)
-            sub = self._build_coercer(real_type, depth - 1)
-            return lambda v, d: sub(v, d)
-
-        if isclass(field_type):
-            # This is needed bcs. of issubclass issues on older versions of python
-            try:
-                is_bm_subclass = issubclass(field_type, BaseModel)
-            except TypeError:
-                # python < 3.11 issue.
-                is_bm_subclass = False
-            if is_bm_subclass:
-                mapper = SchemaCoercionMapper(field_type, max_depth=depth - 1)
-                return lambda v, d: mapper.coerce(v, d) if isinstance(v, dict) else v
-
-        if origin is list:
-            args = get_args(field_type)
-            if len(args) != 1:
-                return self._passthrough
-            sub = self._build_coercer(args[0], depth - 1)
-
-            def list_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, (list, tuple)):
-                    return v
-                return [sub(x, d - 1) for x in v]
-
-            return list_coercer
-
-        if origin is set or field_type is set:
-            args = get_args(field_type)
-            if len(args) > 1:
-                return self._passthrough
-            elif len(args) == 1:
-                sub = self._build_coercer(args[0], depth - 1)
-            else:
-                sub = None  # type: ignore
-
-            def set_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, (list, tuple, set)):
-                    return v
-                if sub is None:
-                    return set(v)
-                return {sub(x, d - 1) for x in v}
-
-            return set_coercer
-        if origin is dict or field_type is dict:
-            args = get_args(field_type)
-            if len(args) != 2:
-
-                def dict_coercer(v: Any, d: Any) -> Any:
-                    if not isinstance(v, dict):
-                        if throw:
-                            raise TypeError(f"Expected dict, got {type(v)}")
-                    return v
-
-                return dict_coercer
-            k_sub = self._build_coercer(args[0], depth - 1)
-            v_sub = self._build_coercer(args[1], depth - 1)
-
-            def dict_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, dict):
-                    if throw:
-                        raise TypeError(f"Expected dict, got {type(v)}")
-                    return v
-                return {k_sub(k, d - 1): v_sub(val, d - 1) for k, val in v.items()}
-
-            return dict_coercer
-
-        if origin is tuple:
-            elem_types = get_args(field_type)
-            if not elem_types:
-                return self._passthrough
-            subs = [self._build_coercer(t, depth - 1) for t in elem_types]
-            return lambda v, d: (
-                tuple(
-                    subs[i](v[i] if i < len(v) else None, d - 1)
-                    for i in range(len(subs))
-                )
-                if isinstance(v, (list, tuple))
-                else v
-            )
-
-        if origin is Union:
-            uargs = get_args(field_type)
-            subs, none_in_union = [], False
-            for ix, arg in enumerate(uargs):
-                if arg is type(None):
-                    none_in_union = True
-                else:
-                    subs.append(
-                        self._build_coercer(arg, depth - 1, throw=ix < len(uargs) - 1)
-                    )
-
-            def union_coercer(v: Any, d: Any) -> Any:
-                if v is None and none_in_union:
-                    return None
-                err = None
-                for sp in subs:
-                    try:
-                        return sp(v, d - 1)
-                    except TypeError as e:
-                        err = e
-                if err:
-                    raise err
-                return v
-
-            return union_coercer
-
-        adapter_fn = _get_adapter(field_type)
-        return lambda v, _d: adapter_fn(v)
-
-    @staticmethod
-    def _passthrough(v: Any, _d: Any) -> Any:  # noqa: D401
-        return v
-
-
-_adapter_cache: dict[Any, Callable[[Any], Any]] = {}
-
-
-_IDENTITY_TYPES: tuple[type[Any], ...] = (
-    int,
-    float,
-    str,
-    bool,
-    bytes,
-    bytearray,
-    complex,
-    memoryview,
-    type(None),
-)
-
-
-@functools.lru_cache(maxsize=2048)
-def _adapter_for(tp: Any) -> Callable[[Any], Any]:  # noqa: D401
-    try:
-        config = (
-            None
-            if (issubclass(tp, BaseModel) or is_dataclass(tp) or is_typeddict(tp))
-            else ConfigDict(arbitrary_types_allowed=True)
-        )
-    except TypeError:
-        config = None
-    return TypeAdapter(tp, config=config).validate_python
-
-
-def _get_adapter(tp: Any) -> Callable[[Any], Any]:
-    try:
-        return _adapter_cache[tp]
-    except KeyError:
-        fn = _adapter_for(tp)
-        _adapter_cache[tp] = fn
-        return fn

libs/langgraph/langgraph/graph/state.py

@@ -64,7 +64,6 @@ from langgraph.graph.graph import (
     Graph,
     Send,
 )
-from langgraph.graph.schema_utils import SchemaCoercionMapper
 from langgraph.managed.base import (
     ChannelKeyPlaceholder,
     ChannelTypePlaceholder,
@@ -320,12 +319,18 @@ class StateGraph(Graph):
 
         Example:
             ```python
+            from typing_extensions import TypedDict
+
+            from langchain_core.runnables import RunnableConfig
             from langgraph.graph import START, StateGraph
 
-            def my_node(state, config):
+            class State(TypedDict):
+                x: int
+
+            def my_node(state: State, config: RunnableConfig) -> State:
                 return {"x": state["x"] + 1}
 
-            builder = StateGraph(dict)
+            builder = StateGraph(State)
             builder.add_node(my_node)  # node name will be 'my_node'
             builder.add_edge(START, "my_node")
             graph = builder.compile()
@@ -335,7 +340,7 @@ class StateGraph(Graph):
 
         Example: Customize the name:
             ```python
-            builder = StateGraph(dict)
+            builder = StateGraph(State)
             builder.add_node("my_fair_node", my_node)
             builder.add_edge(START, "my_fair_node")
             graph = builder.compile()
@@ -1042,11 +1047,8 @@ def _pick_mapper(
 ) -> Optional[Callable[[Any], Any]]:
     if state_keys == ["__root__"]:
         return None
-    if isclass(schema):
-        if issubclass(schema, dict):
-            return None
-        if issubclass(schema, BaseModel):
-            return SchemaCoercionMapper(schema, type_hints=type_hints)
+    if isclass(schema) and issubclass(schema, dict):
+        return None
     return partial(_coerce_state, schema)
 
 

libs/langgraph/langgraph/pregel/__init__.py

@@ -2214,12 +2214,14 @@ class Pregel(PregelProtocol):
             validate_keys(output_keys, self.channels)
         interrupt_before = interrupt_before or self.interrupt_before_nodes
         interrupt_after = interrupt_after or self.interrupt_after_nodes
-        stream_mode = stream_mode if stream_mode is not None else self.stream_mode
+        if stream_mode is None and CONFIG_KEY_TASK_ID in config.get(CONF, {}):
+            # if being called as a node in another graph, default to values mode
+            # but don't overwrite stream_mode arg if provided
+            stream_mode = ["values"]
+        elif stream_mode is None:
+            stream_mode = self.stream_mode
         if not isinstance(stream_mode, list):
             stream_mode = [stream_mode]
-        if CONFIG_KEY_TASK_ID in config.get(CONF, {}):
-            # if being called as a node in another graph, always use values mode
-            stream_mode = ["values"]
         if self.checkpointer is False:
             checkpointer: BaseCheckpointSaver | None = None
         elif CONFIG_KEY_CHECKPOINTER in config.get(CONF, {}):

libs/langgraph/langgraph/pregel/retry.py

@@ -41,7 +41,7 @@ def run_with_retry(
         except ParentCommand as exc:
             ns: str = config[CONF][CONFIG_KEY_CHECKPOINT_NS]
             cmd = exc.args[0]
-            if cmd.graph == ns:
+            if cmd.graph in (ns, task.name):
                 # this command is for the current graph, handle it
                 for w in task.writers:
                     w.invoke(cmd, config)
@@ -137,7 +137,7 @@ async def arun_with_retry(
         except ParentCommand as exc:
             ns: str = config[CONF][CONFIG_KEY_CHECKPOINT_NS]
             cmd = exc.args[0]
-            if cmd.graph == ns:
+            if cmd.graph in (ns, task.name):
                 # this command is for the current graph, handle it
                 for w in task.writers:
                     w.invoke(cmd, config)

libs/langgraph/langgraph/pregel/runner.py

@@ -431,7 +431,7 @@ class PregelRunner:
                         writes.extend(resumes)
                     self.put_writes()(task.id, writes)  # type: ignore[misc]
             elif isinstance(exception, GraphBubbleUp):
-                raise exception
+                pass
             else:
                 # save error to checkpointer
                 task.writes.append((ERROR, exception))
@@ -457,7 +457,7 @@ def _should_stop_others(
         if fut.cancelled():
             continue
         elif exc := fut.exception():
-            if not isinstance(exc, GraphBubbleUp):
+            if not isinstance(exc, GraphBubbleUp) and fut not in SKIP_RERAISE_SET:
                 return True
 
     return False

libs/langgraph/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "0.4.6"
+version = "0.4.8"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.9"

libs/langgraph/tests/test_pregel.py

@@ -5514,8 +5514,11 @@ def test_runnable_passthrough_node_graph() -> None:
     assert graph.get_graph(xray=True).to_json() == graph.get_graph(xray=False).to_json()
 
 
+@pytest.mark.parametrize("subgraph_persist", [True, False])
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
-def test_parent_command(request: pytest.FixtureRequest, checkpointer_name: str) -> None:
+def test_parent_command(
+    request: pytest.FixtureRequest, checkpointer_name: str, subgraph_persist: bool
+) -> None:
     from langchain_core.messages import BaseMessage
     from langchain_core.tools import tool
 
@@ -5527,7 +5530,7 @@ def test_parent_command(request: pytest.FixtureRequest, checkpointer_name: str)
     subgraph_builder = StateGraph(MessagesState)
     subgraph_builder.add_node("tool", get_user_name)
     subgraph_builder.add_edge(START, "tool")
-    subgraph = subgraph_builder.compile()
+    subgraph = subgraph_builder.compile(checkpointer=subgraph_persist)
 
     class CustomParentState(TypedDict):
         messages: Annotated[list[BaseMessage], add_messages]
@@ -6873,7 +6876,7 @@ def test_sync_streaming_with_functional_api() -> None:
     should be greater than the time delay between the two tasks.
     """
 
-    time_delay = 0.01
+    time_delay = 0.05
 
     @task()
     def slow() -> dict:
@@ -8796,3 +8799,49 @@ def test_imp_exception(
 
     thread1 = {"configurable": {"thread_id": "1"}}
     assert my_workflow.invoke(1, thread1) == "done"
+
+    assert [c for c in my_workflow.stream(1, thread1)] == [
+        {"my_task": 2},
+        {"my_task": 2},
+        {"my_workflow": "done"},
+    ]
+
+
+@pytest.mark.parametrize("subgraph_persist", [True, False])
+def test_parent_command_goto(
+    sync_checkpointer: BaseCheckpointSaver, subgraph_persist: bool
+) -> None:
+    class State(TypedDict):
+        dialog_state: Annotated[list[str], operator.add]
+
+    def node_a_child(state):
+        return {"dialog_state": ["a_child_state"]}
+
+    def node_b_child(state):
+        return Command(
+            graph=Command.PARENT,
+            goto="node_b_parent",
+            update={"dialog_state": ["b_child_state"]},
+        )
+
+    sub_builder = StateGraph(State)
+    sub_builder.add_node(node_a_child)
+    sub_builder.add_node(node_b_child)
+    sub_builder.add_edge(START, "node_a_child")
+    sub_builder.add_edge("node_a_child", "node_b_child")
+    sub_graph = sub_builder.compile(checkpointer=subgraph_persist)
+
+    def node_b_parent(state):
+        return {"dialog_state": ["node_b_parent"]}
+
+    main_builder = StateGraph(State)
+    main_builder.add_node(node_b_parent)
+    main_builder.add_edge(START, "subgraph_node")
+    main_builder.add_node("subgraph_node", sub_graph, destinations=("node_b_parent",))
+
+    main_graph = main_builder.compile(sync_checkpointer, name="parent")
+    config = {"configurable": {"thread_id": 1}}
+
+    assert main_graph.invoke(input={"dialog_state": ["init_state"]}, config=config) == {
+        "dialog_state": ["init_state", "b_child_state", "node_b_parent"]
+    }

libs/langgraph/tests/test_pregel_async.py

@@ -6772,8 +6772,9 @@ async def test_debug_nested_subgraphs(async_checkpointer: BaseCheckpointSaver):
                 assert stream_task.get("state") == history_task.state
 
 
+@pytest.mark.parametrize("subgraph_persist", [True, False])
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
-async def test_parent_command(checkpointer_name: str) -> None:
+async def test_parent_command(checkpointer_name: str, subgraph_persist: bool) -> None:
     from langchain_core.messages import BaseMessage
     from langchain_core.tools import tool
 
@@ -6785,7 +6786,7 @@ async def test_parent_command(checkpointer_name: str) -> None:
     subgraph_builder = StateGraph(MessagesState)
     subgraph_builder.add_node("tool", get_user_name)
     subgraph_builder.add_edge(START, "tool")
-    subgraph = subgraph_builder.compile()
+    subgraph = subgraph_builder.compile(checkpointer=subgraph_persist)
 
     class CustomParentState(TypedDict):
         messages: Annotated[list[BaseMessage], add_messages]
@@ -9176,3 +9177,313 @@ async def test_imp_exception(
 
     thread1 = {"configurable": {"thread_id": "1"}}
     assert await my_workflow.ainvoke(1, thread1) == "done"
+
+    assert [c async for c in my_workflow.astream(1, thread1)] == [
+        {"my_task": 2},
+        {"my_task": 2},
+        {"my_workflow": "done"},
+    ]
+
+    assert [c async for c in my_workflow.astream_events(1, thread1)] == [
+        {
+            "event": "on_chain_start",
+            "data": {"input": 1},
+            "name": "LangGraph",
+            "tags": [],
+            "run_id": AnyStr(),
+            "metadata": {"thread_id": "1"},
+            "parent_ids": [],
+        },
+        {
+            "event": "on_chain_start",
+            "data": {"input": 1},
+            "name": "my_workflow",
+            "tags": ["graph:step:4"],
+            "run_id": AnyStr(),
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_workflow",
+                "langgraph_triggers": ("__start__",),
+                "langgraph_path": ("__pregel_pull", "my_workflow"),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [AnyStr()],
+        },
+        {
+            "event": "on_chain_start",
+            "data": {"input": {"number": 1}},
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "run_id": AnyStr(),
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "data": {"chunk": 2},
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_end",
+            "data": {"output": 2, "input": {"number": 1}},
+            "run_id": AnyStr(),
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "LangGraph",
+            "tags": [],
+            "metadata": {"thread_id": "1"},
+            "data": {"chunk": {"my_task": 2}},
+            "parent_ids": [],
+        },
+        {
+            "event": "on_chain_start",
+            "data": {"input": {"number": 1}},
+            "name": "task_with_exception",
+            "tags": ["seq:step:1"],
+            "run_id": AnyStr(),
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_start",
+            "data": {"input": {"number": 1}},
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "run_id": AnyStr(),
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "data": {"chunk": 2},
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_end",
+            "data": {"output": 2, "input": {"number": 1}},
+            "run_id": AnyStr(),
+            "name": "my_task",
+            "tags": ["seq:step:1"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_task",
+                "langgraph_triggers": ("__pregel_push",),
+                "langgraph_path": (
+                    "__pregel_push",
+                    ("__pregel_pull", "my_workflow"),
+                    2,
+                    True,
+                ),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [
+                AnyStr(),
+                AnyStr(),
+            ],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "my_workflow",
+            "tags": ["graph:step:4"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_workflow",
+                "langgraph_triggers": ("__start__",),
+                "langgraph_path": ("__pregel_pull", "my_workflow"),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "data": {"chunk": "done"},
+            "parent_ids": [AnyStr()],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "LangGraph",
+            "tags": [],
+            "metadata": {"thread_id": "1"},
+            "data": {"chunk": {"my_task": 2}},
+            "parent_ids": [],
+        },
+        {
+            "event": "on_chain_end",
+            "data": {"output": "done", "input": 1},
+            "run_id": AnyStr(),
+            "name": "my_workflow",
+            "tags": ["graph:step:4"],
+            "metadata": {
+                "thread_id": "1",
+                "langgraph_step": 4,
+                "langgraph_node": "my_workflow",
+                "langgraph_triggers": ("__start__",),
+                "langgraph_path": ("__pregel_pull", "my_workflow"),
+                "langgraph_checkpoint_ns": AnyStr(),
+            },
+            "parent_ids": [AnyStr()],
+        },
+        {
+            "event": "on_chain_stream",
+            "run_id": AnyStr(),
+            "name": "LangGraph",
+            "tags": [],
+            "metadata": {"thread_id": "1"},
+            "data": {"chunk": {"my_workflow": "done"}},
+            "parent_ids": [],
+        },
+        {
+            "event": "on_chain_end",
+            "data": {"output": "done"},
+            "run_id": AnyStr(),
+            "name": "LangGraph",
+            "tags": [],
+            "metadata": {"thread_id": "1"},
+            "parent_ids": [],
+        },
+    ]
+
+
+@pytest.mark.parametrize("subgraph_persist", [True, False])
+async def test_parent_command_goto(
+    async_checkpointer: BaseCheckpointSaver, subgraph_persist: bool
+) -> None:
+    class State(TypedDict):
+        dialog_state: Annotated[list[str], operator.add]
+
+    async def node_a_child(state):
+        return {"dialog_state": ["a_child_state"]}
+
+    async def node_b_child(state):
+        return Command(
+            graph=Command.PARENT,
+            goto="node_b_parent",
+            update={"dialog_state": ["b_child_state"]},
+        )
+
+    sub_builder = StateGraph(State)
+    sub_builder.add_node(node_a_child)
+    sub_builder.add_node(node_b_child)
+    sub_builder.add_edge(START, "node_a_child")
+    sub_builder.add_edge("node_a_child", "node_b_child")
+    sub_graph = sub_builder.compile(checkpointer=subgraph_persist)
+
+    async def node_b_parent(state):
+        return {"dialog_state": ["node_b_parent"]}
+
+    main_builder = StateGraph(State)
+    main_builder.add_node(node_b_parent)
+    main_builder.add_edge(START, "subgraph_node")
+    main_builder.add_node("subgraph_node", sub_graph, destinations=("node_b_parent",))
+
+    main_graph = main_builder.compile(async_checkpointer, name="parent")
+    config = {"configurable": {"thread_id": 1}}
+
+    assert await main_graph.ainvoke(
+        input={"dialog_state": ["init_state"]}, config=config
+    ) == {"dialog_state": ["init_state", "b_child_state", "node_b_parent"]}

libs/prebuilt/langgraph/prebuilt/chat_agent_executor.py

@@ -727,6 +727,10 @@ def create_react_agent(
             ]
 
             if pending_tool_calls:
+                pending_tool_calls = [
+                    tool_node.inject_tool_args(call, state, store)  # type: ignore[arg-type]
+                    for call in pending_tool_calls
+                ]
                 return [Send("tools", [tool_call]) for tool_call in pending_tool_calls]
             elif isinstance(messages[-1], ToolMessage):
                 return entrypoint

libs/prebuilt/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-prebuilt"
-version = "0.2.1"
+version = "0.2.2"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 requires-python = ">=3.9"

libs/prebuilt/tests/test_react_agent.py

@@ -1540,3 +1540,63 @@ def test_post_model_hook_with_structured_output() -> None:
             }
         },
     ]
+
+
+@pytest.mark.parametrize(
+    "state_schema", [AgentStateExtraKey, AgentStateExtraKeyPydantic]
+)
+def test_create_react_agent_inject_vars_with_post_model_hook(
+    state_schema: StateSchemaType,
+) -> None:
+    store = InMemoryStore()
+    namespace = ("test",)
+    store.put(namespace, "test_key", {"bar": 3})
+
+    if issubclass(state_schema, AgentStatePydantic):
+
+        def tool1(
+            some_val: int,
+            state: Annotated[AgentStateExtraKeyPydantic, InjectedState],
+            store: Annotated[BaseStore, InjectedStore()],
+        ) -> str:
+            """Tool 1 docstring."""
+            store_val = store.get(namespace, "test_key").value["bar"]
+            return some_val + state.foo + store_val
+    else:
+
+        def tool1(
+            some_val: int,
+            state: Annotated[dict, InjectedState],
+            store: Annotated[BaseStore, InjectedStore()],
+        ) -> str:
+            """Tool 1 docstring."""
+            store_val = store.get(namespace, "test_key").value["bar"]
+            return some_val + state["foo"] + store_val
+
+    tool_call = {
+        "name": "tool1",
+        "args": {"some_val": 1},
+        "id": "some 0",
+        "type": "tool_call",
+    }
+
+    def post_model_hook(state: dict) -> None:
+        return
+
+    model = FakeToolCallingModel(tool_calls=[[tool_call], []])
+    agent = create_react_agent(
+        model,
+        [tool1],
+        state_schema=state_schema,
+        store=store,
+        post_model_hook=post_model_hook,
+    )
+    input_message = HumanMessage("hi")
+    result = agent.invoke({"messages": [input_message], "foo": 2})
+    assert result["messages"] == [
+        input_message,
+        AIMessage(content="hi", tool_calls=[tool_call], id="0"),
+        _AnyIdToolMessage(content="6", name="tool1", tool_call_id="some 0"),
+        AIMessage("hi-hi-6", id="1"),
+    ]
+    assert result["foo"] == 2

libs/prebuilt/uv.lock

@@ -320,7 +320,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.4.5"
+version = "0.4.7"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -461,7 +461,7 @@ dev = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },

libs/scheduler-kafka/uv.lock

@@ -447,7 +447,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.4.5"
+version = "0.4.7"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -558,7 +558,7 @@ dev = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "../prebuilt" }
 dependencies = [
     { name = "langchain-core" },