One more

minor fix

.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/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/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/concepts/langgraph_control_plane.md

@@ -47,17 +47,22 @@ This section describes various features of the control plane.
 
 For simplicity, the control plane offers two deployment types with different resource allocations: `Development` and `Production`.
 
-| **Deployment Type** | **CPU** | **Memory** | **Scaling**         |
-|---------------------|---------|------------|---------------------|
-| Development         | 1 CPU   | 1 GB       | Up to 1 container   |
-| Production          | 2 CPU   | 2 GB       | Up to 10 containers |
+| **Deployment Type** | **CPU/Memory**  | **Scaling**         | **Database**                                                                     |
+|---------------------|-----------------|---------------------|----------------------------------------------------------------------------------|
+| Development         | 1 CPU, 1 GB RAM | Up to 1 container   | 10 GB disk, no backups                                                           |
+| Production          | 2 CPU, 2 GB RAM | Up to 10 containers | Autoscaling disk, automatic backups, highly available (multi-zone configuration) |
 
 CPU and memory resources are per container.
 
-!!! info "For [Cloud SaaS](../concepts/langgraph_cloud.md)"
+!!! warning "Immutable Deployment Type"
+
+    Once a deployment is created, the deployment type cannot be changed.
+
+!!! info "Resource Customization"
     For `Production` type deployments, resources can be manually increased on a case-by-case basis depending on use case and capacity constraints. Contact support@langchain.dev to request an increase in resources.
 
-!!! info 
+    For `Development` types deployments, database disk size can be manually increased on a case-by-case basis depending on use case and capacity constraints. For most use cases, [TTLs](../how-tos/ttl/configure_ttl.md) should be configured to manage disk usage. Contact support@langchain.dev to request an increase in resources.
+
     Resources for [Self-Hosted Data Plane](../concepts/langgraph_self_hosted_data_plane.md) and [Self-Hosted Control Plane](../concepts/langgraph_self_hosted_control_plane.md) deployments can be fully customized.
 
 ### Database Provisioning

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/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/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,
@@ -1042,11 +1041,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/loop.py

@@ -135,7 +135,6 @@ P = ParamSpec("P")
 INPUT_DONE = object()
 INPUT_RESUMING = object()
 INPUT_SHOULD_VALIDATE = object()
-SPECIAL_CHANNELS = (ERROR, INTERRUPT, SCHEDULED)
 WritesT = Sequence[tuple[str, Any]]
 
 

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

@@ -56,6 +56,10 @@ EXCLUDED_FRAME_FNAMES = (
     "concurrent/futures/_base.py",
 )
 
+SKIP_RERAISE_SET: weakref.WeakSet[Union[concurrent.futures.Future, asyncio.Future]] = (
+    weakref.WeakSet()
+)
+
 
 class FuturesDict(Generic[F, E], dict[F, Optional[PregelExecutableTask]]):
     event: E
@@ -165,7 +169,6 @@ class PregelRunner:
                             futures=weakref.ref(futures),
                             schedule_task=schedule_task,
                             submit=self.submit,
-                            reraise=reraise,
                         ),
                     },
                 )
@@ -207,7 +210,6 @@ class PregelRunner:
                         futures=weakref.ref(futures),
                         schedule_task=schedule_task,
                         submit=self.submit,
-                        reraise=reraise,
                     ),
                 },
                 __reraise_on_exit__=reraise,
@@ -302,7 +304,6 @@ class PregelRunner:
                             futures=weakref.ref(futures),
                             schedule_task=schedule_task,
                             submit=self.submit,
-                            reraise=reraise,
                             loop=loop,
                         ),
                     },
@@ -349,7 +350,6 @@ class PregelRunner:
                             futures=weakref.ref(futures),
                             schedule_task=schedule_task,
                             submit=self.submit,
-                            reraise=reraise,
                             loop=loop,
                         ),
                     },
@@ -434,7 +434,8 @@ class PregelRunner:
                 raise exception
             else:
                 # save error to checkpointer
-                self.put_writes()(task.id, [(ERROR, exception)])  # type: ignore[misc]
+                task.writes.append((ERROR, exception))
+                self.put_writes()(task.id, task.writes)  # type: ignore[misc]
         else:
             if self.node_finished and (
                 task.config is None or TAG_HIDDEN not in task.config.get("tags", [])
@@ -456,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
@@ -494,7 +495,8 @@ def _panic_or_proceed(
     interrupts: list[GraphInterrupt] = []
     while done:
         # if any task failed
-        if exc := _exception(done.pop()):
+        fut = done.pop()
+        if exc := _exception(fut):
             # cancel all pending tasks
             while inflight:
                 inflight.pop().cancel()
@@ -503,7 +505,7 @@ def _panic_or_proceed(
                 if isinstance(exc, GraphInterrupt):
                     # collect interrupts
                     interrupts.append(exc)
-                else:
+                elif fut not in SKIP_RERAISE_SET:
                     raise exc
     # raise combined interrupts
     if interrupts:
@@ -530,7 +532,6 @@ def _call(
         [PregelExecutableTask, int, Optional[Call]], Optional[PregelExecutableTask]
     ],
     submit: weakref.ref[Submit],
-    reraise: bool,
 ) -> concurrent.futures.Future[Any]:
     if asyncio.iscoroutinefunction(func):
         raise RuntimeError("In an sync context async tasks cannot be called")
@@ -582,14 +583,16 @@ def _call(
                         callbacks=callbacks,
                         schedule_task=schedule_task,
                         submit=submit,
-                        reraise=reraise,
                     ),
                 },
-                __reraise_on_exit__=reraise,
+                __reraise_on_exit__=False,
                 # starting a new task in the next tick ensures
                 # updates from this tick are committed/streamed first
                 __next_tick__=True,
             )
+            # exceptions for call() tasks are raised into the parent task
+            # so we should not re-raise at the end of the tick
+            SKIP_RERAISE_SET.add(fut)
             futures()[fut] = next_task  # type: ignore[index]
     fut = cast(Union[asyncio.Future, concurrent.futures.Future], fut)
     # return a chained future to ensure commit() callback is called
@@ -613,7 +616,6 @@ def _acall(
     ],
     submit: weakref.ref[Submit],
     loop: asyncio.AbstractEventLoop,
-    reraise: bool = False,
     stream: bool = False,
 ) -> Union[asyncio.Future[Any], concurrent.futures.Future[Any]]:
     # return a chained future to ensure commit() callback is called
@@ -643,7 +645,6 @@ def _acall(
             schedule_task=schedule_task,
             submit=submit,
             loop=loop,
-            reraise=reraise,
             stream=stream,
         ),
         loop,
@@ -669,7 +670,6 @@ async def _acall_impl(
     ],
     submit: weakref.ref[Submit],
     loop: asyncio.AbstractEventLoop,
-    reraise: bool = False,
     stream: bool = False,
 ) -> None:
     try:
@@ -726,17 +726,19 @@ async def _acall_impl(
                                 schedule_task=schedule_task,
                                 submit=submit,
                                 loop=loop,
-                                reraise=reraise,
                             ),
                         },
-                        __name__=task().name,  # type: ignore[union-attr]
+                        __name__=next_task.name,
                         __cancel_on_exit__=True,
-                        __reraise_on_exit__=reraise,
+                        __reraise_on_exit__=False,
                         # starting a new task in the next tick ensures
                         # updates from this tick are committed/streamed first
                         __next_tick__=True,
                     ),
                 )
+                # exceptions for call() tasks are raised into the parent task
+                # so we should not re-raise at the end of the tick
+                SKIP_RERAISE_SET.add(fut)
                 futures()[fut] = next_task  # type: ignore[index]
         if fut is not None:
             chain_future(fut, destination)

libs/langgraph/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "0.4.5"
+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:
@@ -8769,3 +8772,76 @@ def test_get_graph_root_channel(snapshot: SnapshotAssertion) -> None:
 
     assert json.dumps(graph.get_graph().to_json(), indent=2) == snapshot
     assert graph.get_graph().draw_mermaid(with_styles=False) == snapshot
+
+
+def test_imp_exception(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    @task()
+    def my_task(number: int):
+        time.sleep(0.1)
+        return number * 2
+
+    @task()
+    def task_with_exception(number: int):
+        time.sleep(0.1)
+        raise Exception("This is a test exception")
+
+    @entrypoint(checkpointer=sync_checkpointer)
+    def my_workflow(number: int):
+        my_task(number).result()
+        try:
+            task_with_exception(number).result()
+        except Exception as e:
+            print(f"Exception caught: {e}")
+        my_task(number).result()
+        return "done"
+
+    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]
@@ -9148,3 +9149,341 @@ async def test_draw_invalid():
             {"source": "nothing", "target": "__end__"},
         ],
     }
+
+
+@NEEDS_CONTEXTVARS
+async def test_imp_exception(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    @task()
+    async def my_task(number: int):
+        await asyncio.sleep(0.1)
+        return number * 2
+
+    @task()
+    async def task_with_exception(number: int):
+        await asyncio.sleep(0.1)
+        raise Exception("This is a test exception")
+
+    @entrypoint(checkpointer=async_checkpointer)
+    async def my_workflow(number: int):
+        await my_task(number)
+        try:
+            await task_with_exception(number)
+        except Exception as e:
+            print(f"Exception caught: {e}")
+        await my_task(number)
+        return "done"
+
+    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" },