Merge branch 'wfh/_validate_more' into wfh/_/validate_native_time

My be too slow though. V1 handling is ugly.
Signed-off-by: William Fu-Hinthorn <13333726+hinthornw@users.noreply.github.com>

docs/docs/concepts/persistence.md

@@ -4,6 +4,10 @@ LangGraph has a built-in persistence layer, implemented through checkpointers. W
 
 ![Checkpoints](img/persistence/checkpoints.jpg)
 
+!!! info "LangGraph API handles checkpointing automatically"
+
+    When using the LangGraph API, you don't need to implement or configure checkpointers manually. The API handles all persistence infrastructure for you behind the scenes.
+
 ## Threads
 
 A thread is a unique ID or [thread identifier](#threads) assigned to each checkpoint saved by a checkpointer. When invoking graph with a checkpointer, you **must** specify a `thread_id` as part of the `configurable` portion of the config:
@@ -26,7 +30,7 @@ Let's see what checkpoints are saved when a simple graph is invoked as follows:
 
 ```python
 from langgraph.graph import StateGraph, START, END
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.memory import InMemorySaver
 from typing import Annotated
 from typing_extensions import TypedDict
 from operator import add
@@ -49,7 +53,7 @@ workflow.add_edge(START, "node_a")
 workflow.add_edge("node_a", "node_b")
 workflow.add_edge("node_b", END)
 
-checkpointer = MemorySaver()
+checkpointer = InMemorySaver()
 graph = workflow.compile(checkpointer=checkpointer)
 
 config = {"configurable": {"thread_id": "1"}}
@@ -223,6 +227,10 @@ But, what if we want to retain some information *across threads*? Consider the c
 
 With checkpointers alone, we cannot share information across threads. This motivates the need for the [`Store`](../reference/store.md#langgraph.store.base.BaseStore) interface. As an illustration, we can define an `InMemoryStore` to store information about a user across threads. We simply compile our graph with a checkpointer, as before, and with our new `in_memory_store` variable.
 
+!!!  info "LangGraph API handles stores automatically"
+
+    When using the LangGraph API, you don't need to implement or configure stores manually. The API handles all storage infrastructure for you behind the scenes.
+
 ### Basic Usage
 
 First, let's showcase this in isolation without using LangGraph.
@@ -324,10 +332,10 @@ store.put(
 With this all in place, we use the `in_memory_store` in LangGraph. The `in_memory_store` works hand-in-hand with the checkpointer: the checkpointer saves state to threads, as discussed above, and the `in_memory_store` allows us to store arbitrary information for access *across* threads. We compile the graph with both the checkpointer and the `in_memory_store` as follows. 
 
 ```python
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.memory import InMemorySaver
 
 # We need this because we want to enable threads (conversations)
-checkpointer = MemorySaver()
+checkpointer = InMemorySaver()
 
 # ... Define the graph ...
 
@@ -440,6 +448,7 @@ Under the hood, checkpointing is powered by checkpointer objects that conform to
 * `langgraph-checkpoint-sqlite`: An implementation of LangGraph checkpointer that uses SQLite database ([SqliteSaver][langgraph.checkpoint.sqlite.SqliteSaver] / [AsyncSqliteSaver][langgraph.checkpoint.sqlite.aio.AsyncSqliteSaver]). Ideal for experimentation and local workflows. Needs to be installed separately.
 * `langgraph-checkpoint-postgres`: An advanced checkpointer that uses Postgres database ([PostgresSaver][langgraph.checkpoint.postgres.PostgresSaver] / [AsyncPostgresSaver][langgraph.checkpoint.postgres.aio.AsyncPostgresSaver]), used in LangGraph Cloud. Ideal for using in production. Needs to be installed separately.
 
+
 ### Checkpointer interface
 
 Each checkpointer conforms to [BaseCheckpointSaver][langgraph.checkpoint.base.BaseCheckpointSaver] interface and implements the following methods:
@@ -452,7 +461,7 @@ Each checkpointer conforms to [BaseCheckpointSaver][langgraph.checkpoint.base.Ba
 If the checkpointer is used with asynchronous graph execution (i.e. executing the graph via `.ainvoke`, `.astream`, `.abatch`), asynchronous versions of the above methods will be used (`.aput`, `.aput_writes`, `.aget_tuple`, `.alist`).
 
 !!! note Note
-    For running your graph asynchronously, you can use `MemorySaver`, or async versions of Sqlite/Postgres checkpointers -- `AsyncSqliteSaver` / `AsyncPostgresSaver` checkpointers.
+    For running your graph asynchronously, you can use `InMemorySaver`, or async versions of Sqlite/Postgres checkpointers -- `AsyncSqliteSaver` / `AsyncPostgresSaver` checkpointers.
 
 ### Serializer
 

docs/docs/how-tos/persistence-functional.ipynb

@@ -16,6 +16,10 @@
     "    - [Memory](../../concepts/memory/)\n",
     "    - [Chat Models](https://python.langchain.com/docs/concepts/chat_models/)\n",
     "\n",
+    "!!! info \"Not needed for LangGraph API users\"\n",
+    "\n",
+    "    If you're using the LangGraph API, you needn't manually implement a checkpointer. The API automatically handles checkpointing for you. This guide is relevant when implementing LangGraph in your own custom server.\n",
+    "\n",
     "Many AI applications need memory to share context across multiple interactions on the same [thread](../../concepts/persistence#threads) (e.g., multiple turns of a conversation). In LangGraph functional API, this kind of memory can be added to any [entrypoint()][langgraph.func.entrypoint] workflow using [thread-level persistence](https://langchain-ai.github.io/langgraph/concepts/persistence).\n",
     "\n",
     "When creating a LangGraph workflow, you can set it up to persist its results by using a [checkpointer](https://langchain-ai.github.io/langgraph/reference/checkpoints/#basecheckpointsaver):\n",

docs/docs/how-tos/persistence.ipynb

@@ -31,6 +31,10 @@
     "    </p>\n",
     "</div> \n",
     "\n",
+    "!!! info \"Not needed for LangGraph API users\"\n",
+    "\n",
+    "    If you're using the LangGraph API, you needn't manually implement a checkpointer. The API automatically handles checkpointing for you. This guide is relevant when implementing LangGraph in your own custom server.\n",
+    "\n",
     "Many AI applications need memory to share context across multiple interactions. In LangGraph, this kind of memory can be added to any [StateGraph](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.StateGraph) using [thread-level persistence](https://langchain-ai.github.io/langgraph/concepts/persistence) .\n",
     "\n",
     "When creating any LangGraph graph, you can set it up to persist its state by adding a [checkpointer](https://langchain-ai.github.io/langgraph/reference/checkpoints/#basecheckpointsaver) when compiling the graph:\n",

docs/docs/how-tos/persistence_postgres.ipynb

@@ -26,6 +26,10 @@
     "    </p>\n",
     "</div> \n",
     "\n",
+    "!!! info \"Not needed for LangGraph API users\"\n",
+    "\n",
+    "    If you're using the LangGraph API, you needn't manually implement a checkpointer. The API automatically handles checkpointing for you. This guide is relevant when implementing LangGraph in your own custom server.\n",
+    "\n",
     "When creating LangGraph agents, you can also set them up so that they persist their state. This allows you to do things like interact with an agent multiple times and have it remember previous interactions.\n",
     "\n",
     "This how-to guide shows how to use `Postgres` as the backend for persisting checkpoint state using the [`langgraph-checkpoint-postgres`](https://github.com/langchain-ai/langgraph/tree/main/libs/checkpoint-postgres) library.\n",
@@ -44,7 +48,7 @@
     "...\n",
     "```\n",
     "\n",
-    "!!! info \"Setup\"",
+    "!!! info \"Setup\"\n",
     "\n",
     "    You need to run `.setup()` once on your checkpointer to initialize the database before you can use it."
    ]

libs/checkpoint/langgraph/checkpoint/memory/__init__.py

@@ -38,6 +38,8 @@ class InMemorySaver(
         Only use `InMemorySaver` for debugging or testing purposes.
         For production use cases we recommend installing [langgraph-checkpoint-postgres](https://pypi.org/project/langgraph-checkpoint-postgres/) and using `PostgresSaver` / `AsyncPostgresSaver`.
 
+        If you are using the LangGraph Platform, no checkpointer needs to be specified. The correct managed checkpointer will be used automatically.
+
     Args:
         serde (Optional[SerializerProtocol]): The serializer to use for serializing and deserializing checkpoints. Defaults to None.
 

libs/langgraph/bench/__main__.py

@@ -9,6 +9,7 @@ from bench.fanout_to_subgraph import fanout_to_subgraph, fanout_to_subgraph_sync
 from bench.pydantic_state import pydantic_state
 from bench.react_agent import react_agent
 from bench.sequential import create_sequential
+from bench.wide_dict import wide_dict
 from bench.wide_state import wide_state
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.graph import StateGraph
@@ -251,6 +252,102 @@ benchmarks = (
             ]
         },
     ),
+    (
+        "wide_dict_25x300",
+        wide_dict(300).compile(checkpointer=None),
+        wide_dict(300).compile(checkpointer=None),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(5)
+                    }
+                    for i in range(5)
+                }
+            ]
+        },
+    ),
+    (
+        "wide_dict_25x300_checkpoint",
+        wide_dict(300).compile(checkpointer=MemorySaver()),
+        wide_dict(300).compile(checkpointer=MemorySaver()),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(5)
+                    }
+                    for i in range(5)
+                }
+            ]
+        },
+    ),
+    (
+        "wide_dict_15x600",
+        wide_dict(600).compile(checkpointer=None),
+        wide_dict(600).compile(checkpointer=None),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(5)
+                    }
+                    for i in range(3)
+                }
+            ]
+        },
+    ),
+    (
+        "wide_dict_15x600_checkpoint",
+        wide_dict(600).compile(checkpointer=MemorySaver()),
+        wide_dict(600).compile(checkpointer=MemorySaver()),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(5)
+                    }
+                    for i in range(3)
+                }
+            ]
+        },
+    ),
+    (
+        "wide_dict_9x1200",
+        wide_dict(1200).compile(checkpointer=None),
+        wide_dict(1200).compile(checkpointer=None),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(3)
+                    }
+                    for i in range(3)
+                }
+            ]
+        },
+    ),
+    (
+        "wide_dict_9x1200_checkpoint",
+        wide_dict(1200).compile(checkpointer=MemorySaver()),
+        wide_dict(1200).compile(checkpointer=MemorySaver()),
+        {
+            "messages": [
+                {
+                    str(i) * 10: {
+                        str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                        for j in range(3)
+                    }
+                    for i in range(3)
+                }
+            ]
+        },
+    ),
     (
         "sequential_10",
         create_sequential(10).compile(),

libs/langgraph/bench/wide_dict.py

@@ -0,0 +1,153 @@
+import operator
+from functools import partial
+from random import choice
+from typing import Annotated, Optional, Sequence
+
+from typing_extensions import TypedDict
+
+from langgraph.constants import END, START
+from langgraph.graph.state import StateGraph
+
+
+def wide_dict(n: int) -> StateGraph:
+    class State(TypedDict):
+        messages: Annotated[list, operator.add]
+        trigger_events: Annotated[list, operator.add]
+        """The external events that are converted by the graph."""
+        primary_issue_medium: Annotated[str, lambda x, y: y or x]
+        autoresponse: Annotated[Optional[dict], lambda _, y: y]  # Always overwrite
+        issue: Annotated[dict | None, lambda x, y: y if y else x]
+        relevant_rules: Optional[list[dict]]
+        """SOPs fetched from the rulebook that are relevant to the current conversation."""
+        memory_docs: Optional[list[dict]]
+        """Memory docs fetched from the memory service that are relevant to the current conversation."""
+        categorizations: Annotated[list[dict], operator.add]
+        """The issue categorizations auto-generated by the AI."""
+        responses: Annotated[list[dict], operator.add]
+        """The draft responses recommended by the AI."""
+
+        user_info: Annotated[Optional[dict], lambda x, y: y if y is not None else x]
+        """The current user state (by email)."""
+        crm_info: Annotated[Optional[dict], lambda x, y: y if y is not None else x]
+        """The CRM information for organization the current user is from."""
+        email_thread_id: Annotated[
+            Optional[str], lambda x, y: y if y is not None else x
+        ]
+        """The current email thread ID."""
+        slack_participants: Annotated[dict, operator.or_]
+        """The growing list of current slack participants."""
+        bot_id: Optional[str]
+        """The ID of the bot user in the slack channel."""
+        notified_assignees: Annotated[dict, operator.or_]
+
+    list_fields = {
+        "messages",
+        "trigger_events",
+        "categorizations",
+        "responses",
+        "memory_docs",
+        "relevant_rules",
+    }
+    dict_fields = {
+        "user_info",
+        "crm_info",
+        "slack_participants",
+        "notified_assignees",
+        "autoresponse",
+        "issue",
+    }
+
+    def read_write(read: str, write: Sequence[str], input: State) -> dict:
+        val = input.get(read)
+        val = {val: val} if isinstance(val, str) else val
+        val_single = val[-1] if isinstance(val, list) else val
+        val_list = val if isinstance(val, list) else [val]
+        return {
+            k: val_list
+            if k in list_fields
+            else val_single
+            if k in dict_fields
+            else "".join(choice("abcdefghijklmnopqrstuvwxyz") for _ in range(n))
+            for k in write
+        }
+
+    builder = StateGraph(State)
+    builder.add_edge(START, "one")
+    builder.add_node(
+        "one",
+        partial(read_write, "messages", ["trigger_events", "primary_issue_medium"]),
+    )
+    builder.add_edge("one", "two")
+    builder.add_node(
+        "two",
+        partial(read_write, "trigger_events", ["autoresponse", "issue"]),
+    )
+    builder.add_edge("two", "three")
+    builder.add_edge("two", "four")
+    builder.add_node(
+        "three",
+        partial(read_write, "autoresponse", ["relevant_rules"]),
+    )
+    builder.add_node(
+        "four",
+        partial(
+            read_write,
+            "trigger_events",
+            ["categorizations", "responses", "memory_docs"],
+        ),
+    )
+    builder.add_node(
+        "five",
+        partial(
+            read_write,
+            "categorizations",
+            [
+                "user_info",
+                "crm_info",
+                "email_thread_id",
+                "slack_participants",
+                "bot_id",
+                "notified_assignees",
+            ],
+        ),
+    )
+    builder.add_edge(["three", "four"], "five")
+    builder.add_edge("five", "six")
+    builder.add_node(
+        "six",
+        partial(read_write, "responses", ["messages"]),
+    )
+    builder.add_conditional_edges(
+        "six", lambda state: END if len(state["messages"]) > n else "one"
+    )
+
+    return builder
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    import uvloop
+
+    from langgraph.checkpoint.memory import MemorySaver
+
+    graph = wide_dict(1000).compile(checkpointer=MemorySaver())
+    input = {
+        "messages": [
+            {
+                str(i) * 10: {
+                    str(j) * 10: ["hi?" * 10, True, 1, 6327816386138, None] * 5
+                    for j in range(50)
+                }
+                for i in range(50)
+            }
+        ]
+    }
+    config = {"configurable": {"thread_id": "1"}, "recursion_limit": 20000000000}
+
+    async def run():
+        async for c in graph.astream(input, config=config):
+            print(c.keys())
+
+    uvloop.install()
+    asyncio.run(run())

libs/langgraph/bench/wide_state.py

@@ -1,6 +1,7 @@
 import operator
 from dataclasses import dataclass, field
 from functools import partial
+from random import choice
 from typing import Annotated, Optional, Sequence
 
 from langgraph.constants import END, START
@@ -49,12 +50,34 @@ def wide_state(n: int) -> StateGraph:
         """The ID of the bot user in the slack channel."""
         notified_assignees: Annotated[dict, operator.or_] = field(default_factory=dict)
 
+    list_fields = {
+        "messages",
+        "trigger_events",
+        "categorizations",
+        "responses",
+        "memory_docs",
+        "relevant_rules",
+    }
+    dict_fields = {
+        "user_info",
+        "crm_info",
+        "slack_participants",
+        "notified_assignees",
+        "autoresponse",
+        "issue",
+    }
+
     def read_write(read: str, write: Sequence[str], input: State) -> dict:
         val = getattr(input, read)
+        val = {val: val} if isinstance(val, str) else val
         val_single = val[-1] if isinstance(val, list) else val
         val_list = val if isinstance(val, list) else [val]
         return {
-            k: val_list if isinstance(getattr(input, k), list) else val_single
+            k: val_list
+            if k in list_fields
+            else val_single
+            if k in dict_fields
+            else "".join(choice("abcdefghijklmnopqrstuvwxyz") for _ in range(n))
             for k in write
         }
 

libs/langgraph/langgraph/graph/schema_utils.py

@@ -16,46 +16,106 @@ from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
 from typing_extensions import Annotated
 
+__all__ = ["SchemaCoercionMapper"]
+
 logger = logging.getLogger(__name__)
 
 
+try:
+    # Pydantic v2.
+    from pydantic import TypeAdapter
+
+    try:
+        import pydantic.v1.types as v1_types_
+        from pydantic.v1 import parse_obj_as
+
+        v1_types = tuple(
+            v for k, v in vars(v1_types_).items() if k in v1_types_.__all__
+        )
+    except ImportError:
+        v1_types = ()
+
+        def parse_obj_as(tp: Any, v: Any) -> Any:  # noqa: D401
+            return v
+
+    def _adapter_for(tp: Any) -> Callable[[Any], Any]:  # noqa: D401
+        if tp in v1_types:
+            return lambda v: parse_obj_as(tp, v)
+        try:
+            return TypeAdapter(tp).validate_python
+        except TypeError:
+            return lambda v: parse_obj_as(tp, v)
+
+except ImportError:  # Pydantic V1
+    from pydantic import parse_obj_as
+
+    def _adapter_for(tp: Any) -> Callable[[Any], Any]:  # noqa: D401
+        return lambda v: parse_obj_as(tp, v)
+
+
+_adapter_cache: dict[Any, Callable[[Any], Any]] = {}
+
+
+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
+
+
+_IDENTITY_TYPES: tuple[type[Any], ...] = (
+    int,
+    float,
+    str,
+    bool,
+    bytes,
+    bytearray,
+    complex,
+    memoryview,
+    type(None),
+)
+
+
 _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":
-        if schema not in _cache:
-            _cache[schema] = {}
-        if max_depth in _cache[schema]:
-            return _cache[schema][max_depth]
-
+        by_depth = _cache.setdefault(schema, {})
+        if max_depth in by_depth:
+            return by_depth[max_depth]
         inst = super().__new__(cls)
-        _cache[schema][max_depth] = inst
+        by_depth[max_depth] = inst
         return inst
 
     def __init__(
         self,
         schema: Type[Any],
         type_hints: Optional[dict[str, Any]] = None,
+        *,
         max_depth: int = 12,
-    ):
-        if hasattr(self, "_inited"):
+    ) -> None:
+        if getattr(self, "_initialised", False):
             return
-        self._inited = True
+        self._initialised = True
+
         self.schema = schema
-        self.type_hints = (
-            type_hints
-            if type_hints is not None
-            else get_type_hints(schema, localns={schema.__name__: schema})
-        )
         self.max_depth = max_depth
+        self.type_hints = type_hints or get_type_hints(
+            schema, localns={schema.__name__: schema}
+        )
 
         if issubclass(schema, BaseModel):
             self._fields = {
@@ -63,7 +123,6 @@ class SchemaCoercionMapper:
                 for n, f in schema.model_fields.items()
             }
             self._construct: Callable[..., Any] = schema.model_construct
-
         elif issubclass(schema, BaseModelV1):
             self._fields = {
                 n: self.type_hints.get(n, f.annotation)
@@ -71,56 +130,61 @@ class SchemaCoercionMapper:
             }
             self._construct = schema.construct
         else:
-            raise TypeError("Schema is neither valid Pydantic v1 nor v2 model.")
-        self._field_coercers: Optional[dict[str, Callable[[Any, Any], Any]]] = None
+            raise TypeError("Schema is neither a Pydantic v1 nor 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)
+        return self.schema(**input_data)
 
     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
-        processed = {}
+
         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]:
+        self, field_type: Any, depth: int, *, throw: bool = False
+    ) -> Callable[[Any, int], 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):
-            is_class_ = True
-            try:
-                is_base_model = issubclass(field_type, BaseModel)
-            except TypeError:
-                is_class_ = False
-                is_base_model = False
 
-            if is_base_model:
+        if isclass(field_type):
+            try:
+                is_bm_v2 = issubclass(field_type, BaseModel)
+            except TypeError:
+                is_bm_v2 = False
+            if is_bm_v2 or (
+                isclass(field_type) and issubclass(field_type, BaseModelV1)
+            ):
                 mapper = SchemaCoercionMapper(field_type, max_depth=depth - 1)
                 return lambda v, d: mapper.coerce(v, d) if isinstance(v, dict) else v
-            if is_class_ and issubclass(field_type, BaseModelV1):
-                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 or field_type is list:
+
+        if origin in (list, set):
             args = get_args(field_type)
             if len(args) != 1:
-                return lambda v, d: v
+                return self._passthrough
             sub = self._build_coercer(args[0], depth - 1)
 
             def list_coercer(v: Any, d: Any) -> Any:
@@ -129,10 +193,11 @@ class SchemaCoercionMapper:
                 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 lambda v, d: v
+                return self._passthrough
             sub = self._build_coercer(args[0], depth - 1)
 
             def set_coercer(v: Any, d: Any) -> Any:
@@ -165,20 +230,19 @@ class SchemaCoercionMapper:
             return dict_coercer
 
         if origin is tuple:
-            targs = get_args(field_type)
-            if not targs:
-                return lambda v, d: v
-            subs = [self._build_coercer(a, depth - 1) for a in targs]
+            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
+            )
 
-            def tuple_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, (list, tuple)):
-                    return v
-                out = []
-                for i, sp in enumerate(subs):
-                    out.append(sp(v[i] if i < len(v) else None, d - 1))
-                return tuple(out)
-
-            return tuple_coercer
         if origin is Union:
             uargs = get_args(field_type)
             subs, none_in_union = [], False
@@ -204,7 +268,10 @@ class SchemaCoercionMapper:
                 return v
 
             return union_coercer
-        return self._passthrough
 
-    def _passthrough(self, v: Any, d: Any) -> Any:
+        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

libs/langgraph/langgraph/graph/state.py

@@ -1060,7 +1060,7 @@ def _pick_mapper(
         if issubclass(schema, dict):
             return None
         if issubclass(schema, (BaseModel, BaseModelV1)):
-            return SchemaCoercionMapper(schema, type_hints)
+            return SchemaCoercionMapper(schema, type_hints=type_hints)
     return partial(_coerce_state, schema)
 
 

libs/langgraph/tests/test_pregel.py

@@ -1,9 +1,14 @@
+import datetime
+import decimal
 import enum
 import functools
 import gc
+import ipaddress
 import json
 import logging
 import operator
+import pathlib
+import re
 import threading
 import time
 import uuid
@@ -12,6 +17,7 @@ from collections import Counter, deque
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from dataclasses import dataclass, field
+from enum import Enum
 from random import randrange
 from typing import (
     Annotated,
@@ -3039,15 +3045,45 @@ def test_nested_pydantic_models(version: str) -> None:
     """Test that nested Pydantic models are properly constructed from leaf nodes up."""
 
     # Define nested Pydantic models
+    # Import necessary modules
+
     if version == "v1":
-        from pydantic.v1 import BaseModel, Field
+        from pydantic.v1 import (  # type: ignore
+            BaseModel,
+            ByteSize,
+            Field,
+            SecretStr,
+            confloat,
+            conint,
+            conlist,
+            constr,
+        )
     else:
-        from pydantic import BaseModel, Field
+        from pydantic import (  # type: ignore
+            BaseModel,
+            ByteSize,
+            Field,
+            SecretStr,
+            confloat,
+            conint,
+            conlist,
+            constr,
+        )
 
     class NestedModel(BaseModel):
         value: int
         name: str
 
+    # For constrained types
+    PositiveInt = Annotated[int, Field(gt=0)]
+    NonNegativeFloat = Annotated[float, Field(ge=0)]
+
+    # Enum type
+    class UserRole(Enum):
+        ADMIN = "admin"
+        USER = "user"
+        GUEST = "guest"
+
     # Forward reference model
     class RecursiveModel(BaseModel):
         value: str
@@ -3068,9 +3104,15 @@ def test_nested_pydantic_models(version: str) -> None:
         name: str
         friends: list[str] = Field(default_factory=list)  # IDs of friends
 
+    if version == "v2":
+        conlist_type = conlist(item_type=int, min_length=2, max_length=5)
+    else:
+        conlist_type = conlist(item_type=int, min_items=2, max_items=5)
+
     class State(BaseModel):
         # Basic nested model tests
         top_level: str
+        auuid: uuid.UUID
         nested: NestedModel
         optional_nested: Annotated[Optional[NestedModel], lambda x, y: y, "Foo"]
         dict_nested: dict[str, NestedModel]
@@ -3090,9 +3132,44 @@ def test_nested_pydantic_models(version: str) -> None:
         # Cyclic reference test
         people: dict[str, Person]  # Map of ID -> Person
 
+        # Rich type adapters
+        ip_address: ipaddress.IPv4Address
+        ip_address_v6: ipaddress.IPv6Address
+        amount: decimal.Decimal
+        file_path: pathlib.Path
+        timestamp: datetime.datetime
+        date_only: datetime.date
+        time_only: datetime.time
+        duration: datetime.timedelta
+        immutable_set: frozenset[int]
+        binary_data: bytes
+        pattern: re.Pattern
+        secret: SecretStr
+        file_size: ByteSize
+
+        # Constrained types
+        positive_value: PositiveInt
+        non_negative: NonNegativeFloat
+        limited_string: constr(min_length=3, max_length=10)
+        bounded_int: conint(ge=10, le=100)
+        restricted_float: confloat(gt=0, lt=1)
+        required_list: conlist_type
+
+        # Enum & Literal
+        role: UserRole
+        status: Literal["active", "inactive", "pending"]
+
+        # Annotated & NewType
+        validated_age: Annotated[int, Field(gt=0, lt=120)]
+
+        # Generic containers with validators
+        decimal_list: List[decimal.Decimal]
+        id_tuple: tuple[uuid.UUID, uuid.UUID]
+
     inputs = {
         # Basic nested models
         "top_level": "initial",
+        "auuid": str(uuid.uuid4()),
         "nested": {"value": 42, "name": "test"},
         "optional_nested": {"value": 10, "name": "optional"},
         "dict_nested": {"a": {"value": 5, "name": "a"}},
@@ -3125,6 +3202,35 @@ def test_nested_pydantic_models(version: str) -> None:
                 "friends": ["1", "2"],  # Charlie is friends with Alice and Bob
             },
         },
+        # Rich type adapters
+        "ip_address": "192.168.1.1",
+        "ip_address_v6": "2001:db8::1",
+        "amount": "123.45",
+        "file_path": "/tmp/test.txt",
+        "timestamp": "2025-04-07T10:58:04",
+        "date_only": "2025-04-07",
+        "time_only": "10:58:04",
+        "duration": 3600,  # seconds
+        "immutable_set": [1, 2, 3, 4],
+        "binary_data": b"hello world",
+        "pattern": "^test$",
+        "secret": "password123",
+        "file_size": 1024,
+        # Constrained types
+        "positive_value": 42,
+        "non_negative": 0.0,
+        "limited_string": "test",
+        "bounded_int": 50,
+        "restricted_float": 0.5,
+        "required_list": [10, 20, 30],
+        # Enum & Literal
+        "role": "admin",
+        "status": "active",
+        # Annotated & NewType
+        "validated_age": 30,
+        # Generic containers with validators
+        "decimal_list": ["10.5", "20.75", "30.25"],
+        "id_tuple": [str(uuid.uuid4()), str(uuid.uuid4())],
     }
 
     update = {"top_level": "updated", "nested": {"value": 100, "name": "updated"}}
@@ -3132,7 +3238,42 @@ def test_nested_pydantic_models(version: str) -> None:
     expected = State(**inputs)
 
     def node_fn(state: State) -> dict:
+        # Basic assertions
+        assert isinstance(state.auuid, uuid.UUID)
         assert state == expected
+
+        # Rich type assertions
+        assert isinstance(state.ip_address, ipaddress.IPv4Address)
+        assert isinstance(state.ip_address_v6, ipaddress.IPv6Address)
+        assert isinstance(state.amount, decimal.Decimal)
+        assert isinstance(state.file_path, pathlib.Path)
+        assert isinstance(state.timestamp, datetime.datetime)
+        assert isinstance(state.date_only, datetime.date)
+        assert isinstance(state.time_only, datetime.time)
+        assert isinstance(state.duration, datetime.timedelta)
+        assert isinstance(state.immutable_set, frozenset)
+        assert isinstance(state.binary_data, bytes)
+        assert isinstance(state.pattern, re.Pattern)
+
+        # Constrained types
+        assert state.positive_value > 0
+        assert state.non_negative >= 0
+        assert 3 <= len(state.limited_string) <= 10
+        assert 10 <= state.bounded_int <= 100
+        assert 0 < state.restricted_float < 1
+        assert 2 <= len(state.required_list) <= 5
+
+        # Enum & Literal
+        assert state.role == UserRole.ADMIN
+        assert state.status == "active"
+
+        # Annotated
+        assert 0 < state.validated_age < 120
+
+        # Generic containers
+        assert len(state.decimal_list) == 3
+        assert len(state.id_tuple) == 2
+
         return update
 
     builder = StateGraph(State)

libs/sdk-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.62",
+  "version": "0.0.63",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",

libs/sdk-js/src/client.ts

@@ -340,6 +340,7 @@ export class AssistantsClient extends BaseClient {
     assistantId?: string;
     ifExists?: OnConflictBehavior;
     name?: string;
+    description?: string;
   }): Promise<Assistant> {
     return this.fetch<Assistant>("/assistants", {
       method: "POST",
@@ -350,6 +351,7 @@ export class AssistantsClient extends BaseClient {
         assistant_id: payload.assistantId,
         if_exists: payload.ifExists,
         name: payload.name,
+        description: payload.description,
       },
     });
   }
@@ -367,6 +369,7 @@ export class AssistantsClient extends BaseClient {
       config?: Config;
       metadata?: Metadata;
       name?: string;
+      description?: string;
     },
   ): Promise<Assistant> {
     return this.fetch<Assistant>(`/assistants/${assistantId}`, {
@@ -376,6 +379,7 @@ export class AssistantsClient extends BaseClient {
         config: payload.config,
         metadata: payload.metadata,
         name: payload.name,
+        description: payload.description,
       },
     });
   }

libs/sdk-js/src/schema.ts

@@ -113,6 +113,9 @@ export interface AssistantBase {
 
   /** The name of the assistant */
   name: string;
+
+  /** The description of the assistant */
+  description?: string;
 }
 
 export interface AssistantVersion extends AssistantBase {}