cli: 0.3.3 (#5100)

Let you set "pip_installer": "pip" (or uv) to handle corner cases in install compatibilities

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,6 +1,6 @@
 name: "\U0001F41B Bug Report"
 description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
-labels: ["02 Bug Report"]
+labels: [pending,bug]
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 version: 2.1
 contact_links:
   - name: 🤔 Question or Problem

.github/ISSUE_TEMPLATE/documentation.yml

@@ -1,7 +1,7 @@
 name: Documentation
 description: Report an issue related to the LangGraph documentation.
 title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
-labels: [03 - Documentation]
+labels: [documentation]
 
 body:
 - type: textarea

.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,7 +146,7 @@ jobs:
           fi
 
       - name: Configure GitHub Pages
-        if: github.ref == 'refs/heads/main'
+        if: github.ref == 'refs/heads/v0'
         uses: actions/configure-pages@v5
 
       - name: Upload Pages Artifact
@@ -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

AGENTS.md

@@ -0,0 +1,55 @@
+# AGENTS Instructions
+
+This repository is a monorepo. Each library lives in a subdirectory under `libs/`.
+
+When you modify code in any library, run the following commands in that library's directory before creating a pull request:
+
+- `make format` – run code formatters
+- `make lint` – run the linter
+- `make test` – execute the test suite
+
+To run a particular test file or to pass additional pytest options you can specify the `TEST` variable:
+
+```
+TEST=path/to/test.py make test
+```
+
+Other pytest arguments can also be supplied inside the `TEST` variable.
+
+## Libraries
+
+The repository contains several Python and JavaScript/TypeScript libraries.
+Below is a high-level overview:
+
+- **checkpoint** – base interfaces for LangGraph checkpointers.
+- **checkpoint-postgres** – Postgres implementation of the checkpoint saver.
+- **checkpoint-sqlite** – SQLite implementation of the checkpoint saver.
+- **cli** – official command-line interface for LangGraph.
+- **langgraph** – core framework for building stateful, multi-actor agents.
+- **prebuilt** – high-level APIs for creating and running agents and tools.
+- **sdk-js** – JS/TS SDK for interacting with the LangGraph REST API.
+- **sdk-py** – Python SDK for the LangGraph Platform API.
+
+### Dependency map
+
+The diagram below lists downstream libraries for each production dependency as
+declared in that library's `pyproject.toml` (or `package.json`).
+
+```text
+checkpoint
+├── checkpoint-postgres
+├── checkpoint-sqlite
+├── prebuilt
+└── langgraph
+
+prebuilt
+└── langgraph
+
+sdk-py
+├── langgraph
+└── cli
+
+sdk-js (standalone)
+```
+
+Changes to a library may impact all of its dependents shown above.

Makefile

@@ -0,0 +1,58 @@
+# Define the directories containing projects
+LIBS_DIRS := $(wildcard libs/*)
+
+# Default target
+.PHONY: all
+all: lint format lock test
+
+# Install dependencies for all projects
+.PHONY: install
+install:
+	@echo "Creating virtual environment..."
+	@uv venv
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/pyproject.toml ]; then \
+			echo "Installing dependencies for $$dir"; \
+			uv pip install -e $$dir; \
+		fi; \
+	done
+
+# Lint all projects
+.PHONY: lint
+lint:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lint in $$dir"; \
+			$(MAKE) -C $$dir lint; \
+		fi; \
+	done
+
+# Format all projects
+.PHONY: format
+format:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running format in $$dir"; \
+			$(MAKE) -C $$dir format; \
+		fi; \
+	done
+
+# Lock all projects
+.PHONY: lock
+lock:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lock in $$dir"; \
+			(cd $$dir && uv lock); \
+		fi; \
+	done
+
+# Test all projects
+.PHONY: test
+test:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running test in $$dir"; \
+			$(MAKE) -C $$dir test; \
+		fi; \
+	done

README.md

@@ -12,7 +12,6 @@
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
-[![GitMCP](https://img.shields.io/endpoint?url=https://gitmcp.io/badge/langchain-ai/langgraph)](https://gitmcp.io/langchain-ai/langgraph)
 
 Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.
 

docs/docs/cloud/deployment/self_hosted_control_plane.md

@@ -30,18 +30,16 @@ Before deploying, review the [conceptual guide for the Self-Hosted Control Plane
     1. `LangGraphPlatform CRD`: A CRD for LangGraph Platform deployments. This contains the spec for managing an instance of a LangGraph platform deployment.
     1. `operator`: This operator handles changes to your LangGraph Platform CRDs.
     1. `host-backend`: This is the [control plane](../../concepts/langgraph_control_plane.md).
-1. Two additional images will be used by the chart.
+1. Two additional images will be used by the chart. Use the images that are specified in the latest release.
 
         hostBackendImage:
           repository: "docker.io/langchain/hosted-langserve-backend"
           pullPolicy: IfNotPresent
-          tag: "0.9.80"
         operatorImage:
           repository: "docker.io/langchain/langgraph-operator"
           pullPolicy: IfNotPresent
-          tag: "aa9dff4"
 
-1. In your `langsmith_config.yaml` file, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
+1. In your config file for langsmith (usually `langsmith_config.yaml`, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
 
         config:
           langgraphPlatform:

docs/docs/cloud/how-tos/studio/manage_assistants.md

@@ -2,7 +2,7 @@
 
 !!! info "Prerequisites"
 
-    - [Assistants Overview](../../concepts/assistants.md)
+    - [Assistants Overview](../../../concepts/assistants.md)
 
 LangGraph Studio lets you view, edit, and update your assistants, and allows you to run your graph using these assistant configurations.
 

docs/docs/cloud/reference/api/openapi.json

@@ -3818,6 +3818,14 @@
             "title": "Filter",
             "description": "Optional dictionary of key-value pairs to filter results."
           },
+          "query": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "title": "Query",
+            "description": "Query string for semantic/vector search."
+          },
           "limit": {
             "type": "integer",
             "default": 10,

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/auth.md

@@ -198,7 +198,7 @@ async def add_owner(
 You can register handlers for specific resources and actions by chaining the resource and action names together with the [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) decorator.
 When a request is made, the most specific handler that matches that resource and action is called. Below is an example of how to register handlers for specific resources and actions. For the following setup:
 
-1. Authenticated users are able to create threads, read thread, create runs on threads
+1. Authenticated users are able to create threads, read threads, and create runs on threads
 2. Only users with the "assistants:create" permission are allowed to create new assistants
 3. All other endpoints (e.g., e.g., delete assistant, crons, store) are disabled for all users.
 

docs/docs/concepts/low_level.md

@@ -89,7 +89,7 @@ def node_3(state: PrivateState) -> OutputState:
     # Read from PrivateState, write to OutputState
     return {"graph_output": state["bar"] + " Lance"}
 
-builder = StateGraph(OverallState,input=InputState,output=OutputState)
+builder = StateGraph(OverallState,input_schema=InputState,output_schema=OutputState)
 builder.add_node("node_1", node_1)
 builder.add_node("node_2", node_2)
 builder.add_node("node_3", node_3)
@@ -107,7 +107,7 @@ There are two subtle and important points to note here:
 
 1. We pass `state: InputState` as the input schema to `node_1`. But, we write out to `foo`, a channel in `OverallState`. How can we write out to a state channel that is not included in the input schema? This is because a node _can write to any state channel in the graph state._ The graph state is the union of the state channels defined at initialization, which includes `OverallState` and the filters `InputState` and `OutputState`.
 
-2. We initialize the graph with `StateGraph(OverallState,input=InputState,output=OutputState)`. So, how can we write to `PrivateState` in `node_2`? How does the graph gain access to this schema if it was not passed in the `StateGraph` initialization? We can do this because _nodes can also declare additional state channels_ as long as the state schema definition exists. In this case, the `PrivateState` schema is defined, so we can add `bar` as a new state channel in the graph and write to it.
+2. We initialize the graph with `StateGraph(OverallState,input_schema=InputState,output_schema=OutputState)`. So, how can we write to `PrivateState` in `node_2`? How does the graph gain access to this schema if it was not passed in the `StateGraph` initialization? We can do this because _nodes can also declare additional state channels_ as long as the state schema definition exists. In this case, the `PrivateState` schema is defined, so we can add `bar` as a new state channel in the graph and write to it.
 
 ### Reducers
 
@@ -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,51 @@ 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.
 
+#### Serialization with `pickle`
+
+The default serializer, [`JsonPlusSerializer`][langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer], uses ormsgpack and JSON under the hood, which is not suitable for all types of objects.
+
+If you want to fallback to pickle for objects not currently supported by our msgpack encoder (such as Pandas dataframes),
+you can use the `pickle_fallback` argument of the `JsonPlusSerializer`:
+
+```python
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+
+# ... Define the graph ...
+graph.compile(
+    checkpointer=MemorySaver(serde=JsonPlusSerializer(pickle_fallback=True))
+)
+```
+
+#### 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/concepts/server-mcp.md

@@ -94,7 +94,7 @@ def answer_node(state: InputState):
     return {"answer": "bye", "question": state["question"]}
 
 # Build the graph with explicit schemas
-builder = StateGraph(OverallState, input=InputState, output=OutputState)
+builder = StateGraph(OverallState, input_schema=InputState, output_schema=OutputState)
 builder.add_node(answer_node)
 builder.add_edge(START, "answer_node")
 builder.add_edge("answer_node", END)

docs/docs/concepts/subgraphs.md

@@ -59,8 +59,9 @@ The main question when adding subgraphs is how the parent graph and subgraph com
         response = model.invoke(state["subgraph_messages"])
         return {"subgraph_messages": response}
 
-    subgraph_builder = StateGraph(State)
-    subgraph_builder.add_node(call_model)
+    subgraph_builder = StateGraph(SubgraphMessagesState)
+    subgraph_builder.add_node("call_model_from_subgraph", call_model)
+    subgraph_builder.add_edge(START, "call_model_from_subgraph")
     ...
     # highlight-next-line
     subgraph = subgraph_builder.compile()

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

@@ -439,7 +439,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "6ec0eb77-874e-443e-8c73-93125b515106",
    "metadata": {},
    "outputs": [
@@ -478,7 +478,7 @@
     "\n",
     "\n",
     "# Build the graph with input and output schemas specified\n",
-    "builder = StateGraph(OverallState, input=InputState, output=OutputState)\n",
+    "builder = StateGraph(OverallState, input_schema=InputState, output_schema=OutputState)\n",
     "builder.add_node(answer_node)  # Add the answer node\n",
     "builder.add_edge(START, \"answer_node\")  # Define the starting edge\n",
     "builder.add_edge(\"answer_node\", END)  # Define the ending edge\n",
@@ -1198,7 +1198,7 @@
     "\n",
     "There are many use cases where you may wish for your node to have a custom retry policy, for example if you are calling an API, querying a database, or calling an LLM, etc. LangGraph lets you add retry policies to nodes.\n",
     "\n",
-    "To configure a retry policy, pass the `retry` parameter to the [add_node](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph.add_node). The `retry` parameter takes in a `RetryPolicy` named tuple object. Below we instantiate a `RetryPolicy` object with the default parameters and associate it with a node:\n",
+    "To configure a retry policy, pass the `retry_policy` parameter to the [add_node](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph.add_node). The `retry_policy` parameter takes in a `RetryPolicy` named tuple object. Below we instantiate a `RetryPolicy` object with the default parameters and associate it with a node:\n",
     "\n",
     "```python\n",
     "from langgraph.pregel import RetryPolicy\n",
@@ -1206,7 +1206,7 @@
     "builder.add_node(\n",
     "    \"node_name\",\n",
     "    node_function,\n",
-    "    retry=RetryPolicy(),\n",
+    "    retry_policy=RetryPolicy(),\n",
     ")\n",
     "```"
    ]
@@ -1241,7 +1241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "ad92598c-b688-42fa-aae0-9de36273d584",
    "metadata": {},
    "outputs": [],
@@ -1276,9 +1276,9 @@
     "builder.add_node(\n",
     "    \"query_database\",\n",
     "    query_database,\n",
-    "    retry=RetryPolicy(retry_on=sqlite3.OperationalError),\n",
+    "    retry_policy=RetryPolicy(retry_on=sqlite3.OperationalError),\n",
     ")\n",
-    "builder.add_node(\"model\", call_model, retry=RetryPolicy(max_attempts=5))\n",
+    "builder.add_node(\"model\", call_model, retry_policy=RetryPolicy(max_attempts=5))\n",
     "builder.add_edge(START, \"model\")\n",
     "builder.add_edge(\"model\", \"query_database\")\n",
     "builder.add_edge(\"query_database\", END)\n",
@@ -3416,7 +3416,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -3430,7 +3430,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/many-tools.ipynb

@@ -405,7 +405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "id": "1954a5f1-91e4-4b32-9be9-c8bc1cc43cb5",
    "metadata": {},
    "outputs": [],
@@ -465,7 +465,9 @@
     "\n",
     "graph_builder = StateGraph(State)\n",
     "graph_builder.add_node(\"agent\", agent)\n",
-    "graph_builder.add_node(\"select_tools\", select_tools, retry=RetryPolicy(max_attempts=3))\n",
+    "graph_builder.add_node(\n",
+    "    \"select_tools\", select_tools, retry_policy=RetryPolicy(max_attempts=3)\n",
+    ")\n",
     "\n",
     "tool_node = ToolNode(tools=tools)\n",
     "graph_builder.add_node(\"tools\", tool_node)\n",

docs/docs/how-tos/persistence.ipynb

@@ -1107,10 +1107,10 @@
    "source": [
     "### Use in production\n",
     "\n",
-    "In production, you would want to use a checkpointer backed by a database:\n",
+    "In production, you would want to use a store backed by a database:\n",
     "\n",
     "```python\n",
-    "from langgraph.checkpoint.postgres import PostgresSaver\n",
+    "from langgraph.store.postgres import PostgresStore\n",
     "\n",
     "DB_URI = \"postgresql://postgres:postgres@localhost:5442/postgres?sslmode=disable\"\n",
     "# highlight-next-line\n",

docs/docs/how-tos/use-functional-api.md

@@ -321,7 +321,7 @@ attempts = 0
 # The default RetryPolicy is optimized for retrying specific network errors.
 retry_policy = RetryPolicy(retry_on=ValueError)
 
-@task(retry=retry_policy) 
+@task(retry_policy=retry_policy) 
 def get_info():
     global attempts
     attempts += 1

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/reference/index.md

@@ -22,7 +22,7 @@ Welcome to the LangGraph reference docs! These pages detail the core interfaces
 
 ## LangGraph
 
-The core APIs for the LangGraph opens source library.
+The core APIs for the LangGraph open source library.
 
 - [Graphs](graphs.md): Main graph abstraction and usage.
 - [Functional API](func.md): Functional programming interface for graphs.

docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -580,9 +580,7 @@
     "    ]\n",
     ")\n",
     "\n",
-    "evaluator = prompt | ChatOpenAI(model=\"gpt-4-turbo-preview\").with_structured_output(\n",
-    "    RedTeamingResult, method=\"function_calling\"\n",
-    ")\n",
+    "evaluator = prompt | ChatOpenAI(model=\"gpt-4o\").with_structured_output(RedTeamingResult)\n",
     "\n",
     "\n",
     "def did_resist(run, example):\n",

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

@@ -32,7 +32,7 @@ from typing import Annotated
 
 from typing_extensions import TypedDict
 
-from langgraph.graph import StateGraph, START
+from langgraph.graph import StateGraph, START, END
 from langgraph.graph.message import add_messages
 
 
@@ -100,7 +100,16 @@ Add an `entry` point to tell the graph **where to start its work** each time it
 graph_builder.add_edge(START, "chatbot")
 ```
 
-## 5. Compile the graph
+## 5. Add an `exit` point
+
+Add an `exit` point to indicate **where the graph should finish execution**. This is helpful for more complex flows, but even in a simple graph like this, adding an end node improves clarity.
+
+```python
+graph_builder.add_edge("chatbot", END)
+```
+This tells the graph to terminate after running the chatbot node.
+
+## 6. Compile the graph
 
 Before running the graph, we'll need to compile it. We can do so by calling `compile()`
 on the graph builder. This creates a `CompiledGraph` we can invoke on our state.
@@ -109,7 +118,7 @@ on the graph builder. This creates a `CompiledGraph` we can invoke on our state.
 graph = graph_builder.compile()
 ```
 
-## 6. Visualize the graph (optional)
+## 7. Visualize the graph (optional)
 
 You can visualize the graph using the `get_graph` method and one of the "draw" methods, like `draw_ascii` or `draw_png`. The `draw` methods each require additional dependencies.
 
@@ -126,7 +135,7 @@ except Exception:
 ![basic chatbot diagram](basic-chatbot.png)
 
 
-## 7. Run the chatbot
+## 8. Run the chatbot
 
 Now run the chatbot! 
 
@@ -171,7 +180,7 @@ from typing import Annotated
 from langchain.chat_models import init_chat_model
 from typing_extensions import TypedDict
 
-from langgraph.graph import StateGraph, START
+from langgraph.graph import StateGraph, START, END
 from langgraph.graph.message import add_messages
 
 
@@ -194,6 +203,7 @@ def chatbot(state: State):
 # the node is used.
 graph_builder.add_node("chatbot", chatbot)
 graph_builder.add_edge(START, "chatbot")
+graph_builder.add_edge("chatbot", END)
 graph = graph_builder.compile()
 ```
 

docs/docs/tutorials/get-started/3-add-memory.md

@@ -164,7 +164,7 @@ llm = init_chat_model("anthropic:claude-3-5-sonnet-latest")
 ```
 -->
 
-```python
+```python hl_lines="36 37"
 from typing import Annotated
 
 from langchain.chat_models import init_chat_model
@@ -206,4 +206,4 @@ graph = graph_builder.compile(checkpointer=memory)
 
 ## Next steps
 
-In the next tutorial, you will [add human-in-the-loop to the chatbot](./4-human-in-the-loop.md) to handle situations where it may need guidance or verification before proceeding.
+In the next tutorial, you will [add human-in-the-loop to the chatbot](./4-human-in-the-loop.md) to handle situations where it may need guidance or verification before proceeding.

docs/docs/tutorials/llm-compiler/LLMCompiler.ipynb

@@ -471,7 +471,7 @@
     "\n",
     "_get_pass(\"TAVILY_API_KEY\")\n",
     "\n",
-    "calculate = get_math_tool(ChatOpenAI(model=\"gpt-4-turbo-preview\"))\n",
+    "calculate = get_math_tool(ChatOpenAI(model=\"gpt-4o\"))\n",
     "search = TavilySearchResults(\n",
     "    max_results=1,\n",
     "    description='tavily_search_results_json(query=\"the search query\") - a search engine.',\n",
@@ -540,11 +540,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "================================\u001B[1m System Message \u001B[0m================================\n",
       "\n",
-      "Given a user query, create a plan to solve it with the utmost parallelizability. Each plan should comprise an action from the following \u001b[33;1m\u001b[1;3m{num_tools}\u001b[0m types:\n",
-      "\u001b[33;1m\u001b[1;3m{tool_descriptions}\u001b[0m\n",
-      "\u001b[33;1m\u001b[1;3m{num_tools}\u001b[0m. join(): Collects and combines results from prior actions.\n",
+      "Given a user query, create a plan to solve it with the utmost parallelizability. Each plan should comprise an action from the following \u001B[33;1m\u001B[1;3m{num_tools}\u001B[0m types:\n",
+      "\u001B[33;1m\u001B[1;3m{tool_descriptions}\u001B[0m\n",
+      "\u001B[33;1m\u001B[1;3m{num_tools}\u001B[0m. join(): Collects and combines results from prior actions.\n",
       "\n",
       " - An LLM agent is called upon invoking join() to either finalize the user query or wait until the plans are executed.\n",
       " - join should always be the last action in the plan, and will be called in two scenarios:\n",
@@ -561,11 +561,11 @@
       " - Only use the provided action types. If a query cannot be addressed using these, invoke the join action for the next steps.\n",
       " - Never introduce new actions other than the ones provided.\n",
       "\n",
-      "=============================\u001b[1m Messages Placeholder \u001b[0m=============================\n",
+      "=============================\u001B[1m Messages Placeholder \u001B[0m=============================\n",
       "\n",
-      "\u001b[33;1m\u001b[1;3m{messages}\u001b[0m\n",
+      "\u001B[33;1m\u001B[1;3m{messages}\u001B[0m\n",
       "\n",
-      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "================================\u001B[1m System Message \u001B[0m================================\n",
       "\n",
       "Remember, ONLY respond with the task list in the correct format! E.g.:\n",
       "idx. tool(arg_name=args)\n",
@@ -1030,7 +1030,7 @@
     "joiner_prompt = hub.pull(\"wfh/llm-compiler-joiner\").partial(\n",
     "    examples=\"\"\n",
     ")  # You can optionally add examples\n",
-    "llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")\n",
+    "llm = ChatOpenAI(model=\"gpt-4o\")\n",
     "\n",
     "runnable = joiner_prompt | llm.with_structured_output(\n",
     "    JoinOutputs, method=\"function_calling\"\n",

docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb

@@ -135,7 +135,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import hub\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
     "from langgraph.prebuilt import create_react_agent\n",

docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb

@@ -90,7 +90,11 @@
    "id": "9ac1c2cd-81fb-40eb-8ba1-e9197800cba6",
    "metadata": {},
    "source": [
-    "## Create Index"
+    "## Create Index\n",
+    "\n",
+    "Set up a vector database using OpenAI Embeddings and the Chroma vector database.  \n",
+    "Input URLs of blog posts related to agents, prompt engineering, and large language models (LLMs).  \n",
+    "Generate vector indices for use in Retrieval-Augmented Generation (RAG)."
    ]
   },
   {
@@ -159,6 +163,21 @@
     "</div>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "6cdd5ac0-fa18-4ee9-8051-062a0c56268f",
+   "metadata": {},
+   "source": [
+    "### Router for Query Analysis\n",
+    "\n",
+    "Let’s start with Routing. First, assign the query analysis to the LLM.\n",
+    "\n",
+    "Create a RouteQuery data model and specify it in a structured format for the LLM. The decision for routing should be embedded in the prompt. You need to clearly define which parts of the document should be directed to RAG based on the topic.\n",
+    "\n",
+    "While you could automate this process by having the LLM summarize the RAG documents again, it’s more cost-effective to manually manage this when dealing with large documents, as automation could become expensive.\n",
+    "\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -219,6 +238,18 @@
     "print(question_router.invoke({\"question\": \"What are the types of agent memory?\"}))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "cb248c94-0b0c-4d86-8565-32aa8d7424e4",
+   "metadata": {},
+   "source": [
+    "### Retrieval Grader\n",
+    "\n",
+    "After performing retrieval, evaluate the results. Although you initially decided to use RAG based on the query, the retrieved documents might not be satisfactory. Assess whether the retrieved documents are sufficiently relevant to the query.\n",
+    "\n",
+    "For this, rely on the LLM to evaluate the relevance, providing a binary ‘yes’ or ‘no’ decision."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -309,6 +340,17 @@
     "print(generation)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "cb0ab54a-4a4f-45fa-b1c5-cea1bf4c59d5",
+   "metadata": {},
+   "source": [
+    "### Hallucination Grader\n",
+    "\n",
+    "Verify if the LLM produced any hallucinations by comparing its output to the retrieved facts.  \n",
+    "Provide the LLM’s evaluation in a binary ‘yes’ or ‘no’ format.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -357,6 +399,16 @@
     "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "4f58502a-c25f-4d80-a402-5583b0cd3e41",
+   "metadata": {},
+   "source": [
+    "### Answer Grader\n",
+    "\n",
+    "Evaluate the answer finally."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -405,6 +457,18 @@
     "answer_grader.invoke({\"question\": question, \"generation\": generation})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "af77946c-2646-4039-86b0-e2fde1ab7459",
+   "metadata": {},
+   "source": [
+    "### Question Rewriting\n",
+    "\n",
+    "The original question from user was directly used in RAG.  \n",
+    "However, the user’s question might not be in a form suitable for RAG.  \n",
+    "To improve retrieval, rephrase the question to ensure it aligns better with vector similarity search."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 9,
@@ -450,7 +514,9 @@
    "id": "d07c0b31-b919-4498-869f-9673125c2473",
    "metadata": {},
    "source": [
-    "## Web Search Tool"
+    "## Web Search Tool\n",
+    "\n",
+    "Use Tavily Search tool to get information from the web."
    ]
   },
   {

docs/docs/tutorials/rag/langgraph_crag.ipynb

@@ -185,7 +185,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
     "\n",
     "# Prompt\n",

docs/docs/tutorials/usaco/usaco.ipynb

@@ -1758,7 +1758,7 @@
    "id": "4eb67198-c84f-458b-8baf-783d7246dddc",
    "metadata": {},
    "source": [
-    "Let's let the agent try again. Call `stream` with `None` to just use the inputs loaded from the memory. We will skip our human review for the next few attempats\n",
+    "Let's let the agent try again. Call `stream` with `None` to just use the inputs loaded from the memory. We will skip our human review for the next few attempts\n",
     "to see if it can correct itself."
    ]
   },

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.

examples/rag/langgraph_adaptive_rag.ipynb

@@ -184,7 +184,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_router = llm.with_structured_output(RouteQuery)\n",
     "\n",
     "# Prompt\n",
@@ -235,7 +235,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
     "\n",
     "# Prompt\n",
@@ -328,7 +328,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n",
     "\n",
     "# Prompt\n",
@@ -376,7 +376,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n",
     "\n",
     "# Prompt\n",

examples/rag/langgraph_agentic_rag.ipynb

@@ -200,11 +200,11 @@
      "output_type": "stream",
      "text": [
       "********************Prompt[rlm/rag-prompt]********************\n",
-      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "================================\u001B[1m Human Message \u001B[0m=================================\n",
       "\n",
       "You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.\n",
-      "Question: \u001b[33;1m\u001b[1;3m{question}\u001b[0m \n",
-      "Context: \u001b[33;1m\u001b[1;3m{context}\u001b[0m \n",
+      "Question: \u001B[33;1m\u001B[1;3m{question}\u001B[0m \n",
+      "Context: \u001B[33;1m\u001B[1;3m{context}\u001B[0m \n",
       "Answer:\n"
      ]
     }
@@ -244,7 +244,7 @@
     "        binary_score: str = Field(description=\"Relevance score 'yes' or 'no'\")\n",
     "\n",
     "    # LLM\n",
-    "    model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n",
+    "    model = ChatOpenAI(temperature=0, model=\"gpt-4o\", streaming=True)\n",
     "\n",
     "    # LLM with tool and validation\n",
     "    llm_with_tool = model.with_structured_output(grade)\n",

examples/rag/langgraph_crag.ipynb

@@ -171,7 +171,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
     "\n",
     "# Prompt\n",

examples/rag/langgraph_self_rag.ipynb

@@ -191,7 +191,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
     "\n",
     "# Prompt\n",
@@ -284,7 +284,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n",
     "\n",
     "# Prompt\n",
@@ -332,7 +332,7 @@
     "\n",
     "\n",
     "# LLM with function call\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
     "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n",
     "\n",
     "# Prompt\n",

examples/rag/langgraph_self_rag_pinecone_movies.ipynb

@@ -33,7 +33,9 @@
    "id": "a384cc48-0425-4e8f-aafc-cfb8e56025c9",
    "metadata": {},
    "outputs": [],
-   "source": ["%pip install -qU langchain-pinecone langchain-openai langchainhub langgraph"]
+   "source": [
+    "%pip install -qU langchain-pinecone langchain-openai langchainhub langgraph"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -51,7 +53,9 @@
    "id": "ccc3dae5-1df6-48ca-af8a-50f0e6128876",
    "metadata": {},
    "outputs": [],
-   "source": ["import os\n\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_ENDPOINT\"] = \"https://api.smith.langchain.com\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"<your-api-key>\""]
+   "source": [
+    "import os\n\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_ENDPOINT\"] = \"https://api.smith.langchain.com\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"<your-api-key>\""
+   ]
   },
   {
    "cell_type": "code",
@@ -59,7 +63,9 @@
    "id": "88637820",
    "metadata": {},
    "outputs": [],
-   "source": ["import os\n\nos.environ[\"LANGCHAIN_PROJECT\"] = \"pinecone-devconnect\""]
+   "source": [
+    "import os\n\nos.environ[\"LANGCHAIN_PROJECT\"] = \"pinecone-devconnect\""
+   ]
   },
   {
    "cell_type": "markdown",
@@ -77,7 +83,9 @@
    "id": "565a6d44-2c9f-4fff-b1ec-eea05df9350d",
    "metadata": {},
    "outputs": [],
-   "source": ["from langchain_openai import OpenAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\n\n# use pinecone movies database\n\n# Add to vectorDB\nvectorstore = PineconeVectorStore(\n    embedding=OpenAIEmbeddings(),\n    index_name=\"sample-movies\",\n    text_key=\"summary\",\n)\nretriever = vectorstore.as_retriever()"]
+   "source": [
+    "from langchain_openai import OpenAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\n\n# use pinecone movies database\n\n# Add to vectorDB\nvectorstore = PineconeVectorStore(\n    embedding=OpenAIEmbeddings(),\n    index_name=\"sample-movies\",\n    text_key=\"summary\",\n)\nretriever = vectorstore.as_retriever()"
+   ]
   },
   {
    "cell_type": "code",
@@ -104,7 +112,9 @@
      ]
     }
    ],
-   "source": ["docs = retriever.invoke(\"James Cameron\")\nfor doc in docs:\n    print(\"# \" + doc.metadata[\"title\"])\n    print(doc.page_content)\n    print()"]
+   "source": [
+    "docs = retriever.invoke(\"James Cameron\")\nfor doc in docs:\n    print(\"# \" + doc.metadata[\"title\"])\n    print(doc.page_content)\n    print()"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -120,7 +130,32 @@
    "id": "1fafad21-60cc-483e-92a3-6a7edb1838e3",
    "metadata": {},
    "outputs": [],
-   "source": ["### Retrieval Grader\n\nfrom langchain import hub\nfrom langchain_core.pydantic_v1 import BaseModel, Field\nfrom langchain_openai import ChatOpenAI\n\n\n# Data model\nclass GradeDocuments(BaseModel):\n    \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n\n    binary_score: str = Field(\n        description=\"Documents are relevant to the question, 'yes' or 'no'\"\n    )\n\n\n# https://smith.langchain.com/hub/efriis/self-rag-retrieval-grader\ngrade_prompt = hub.pull(\"efriis/self-rag-retrieval-grader\")\n\n# LLM with function call\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(GradeDocuments)\n\nretrieval_grader = grade_prompt | structured_llm_grader"]
+   "source": [
+    "### Retrieval Grader\n",
+    "\n",
+    "from langchain import hub\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "\n",
+    "# Data model\n",
+    "class GradeDocuments(BaseModel):\n",
+    "    \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n",
+    "\n",
+    "    binary_score: str = Field(\n",
+    "        description=\"Documents are relevant to the question, 'yes' or 'no'\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# https://smith.langchain.com/hub/efriis/self-rag-retrieval-grader\n",
+    "grade_prompt = hub.pull(\"efriis/self-rag-retrieval-grader\")\n",
+    "\n",
+    "# LLM with function call\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
+    "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
+    "\n",
+    "retrieval_grader = grade_prompt | structured_llm_grader"
+   ]
   },
   {
    "cell_type": "code",
@@ -137,7 +172,9 @@
      ]
     }
    ],
-   "source": ["# Test the retrieval grader\nquestion = \"movies starring jason momoa\"\ndocs = retriever.invoke(question)\ndoc_txt = docs[0].page_content\nprint(doc_txt)\nprint(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))"]
+   "source": [
+    "# Test the retrieval grader\nquestion = \"movies starring jason momoa\"\ndocs = retriever.invoke(question)\ndoc_txt = docs[0].page_content\nprint(doc_txt)\nprint(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -163,7 +200,9 @@
      ]
     }
    ],
-   "source": ["### Generate\n\nfrom langchain import hub\nfrom langchain_core.output_parsers import StrOutputParser\n\n# Prompt\nprompt = hub.pull(\"rlm/rag-prompt\")\n\n# LLM\nllm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n\n# Chain\nrag_chain = prompt | llm | StrOutputParser()\n\n# Run\ngeneration = rag_chain.invoke({\"context\": docs, \"question\": question})\nprint(generation)"]
+   "source": [
+    "### Generate\n\nfrom langchain import hub\nfrom langchain_core.output_parsers import StrOutputParser\n\n# Prompt\nprompt = hub.pull(\"rlm/rag-prompt\")\n\n# LLM\nllm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n\n# Chain\nrag_chain = prompt | llm | StrOutputParser()\n\n# Run\ngeneration = rag_chain.invoke({\"context\": docs, \"question\": question})\nprint(generation)"
+   ]
   },
   {
    "cell_type": "code",
@@ -189,7 +228,30 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["### Hallucination Grader\n\n\n# Data model\nclass GradeHallucinations(BaseModel):\n    \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n\n    binary_score: str = Field(\n        description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n    )\n\n\n# LLM with function call\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(GradeHallucinations)\n\n# https://smith.langchain.com/hub/efriis/self-rag-hallucination-grader\nhallucination_prompt = hub.pull(\"efriis/self-rag-hallucination-grader\")\n\nhallucination_grader = hallucination_prompt | structured_llm_grader\nprint(generation)\nhallucination_grader.invoke({\"documents\": docs, \"generation\": generation})"]
+   "source": [
+    "### Hallucination Grader\n",
+    "\n",
+    "\n",
+    "# Data model\n",
+    "class GradeHallucinations(BaseModel):\n",
+    "    \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n",
+    "\n",
+    "    binary_score: str = Field(\n",
+    "        description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# LLM with function call\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
+    "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n",
+    "\n",
+    "# https://smith.langchain.com/hub/efriis/self-rag-hallucination-grader\n",
+    "hallucination_prompt = hub.pull(\"efriis/self-rag-hallucination-grader\")\n",
+    "\n",
+    "hallucination_grader = hallucination_prompt | structured_llm_grader\n",
+    "print(generation)\n",
+    "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})"
+   ]
   },
   {
    "cell_type": "code",
@@ -216,7 +278,31 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["### Answer Grader\n\n\n# Data model\nclass GradeAnswer(BaseModel):\n    \"\"\"Binary score to assess answer addresses question.\"\"\"\n\n    binary_score: str = Field(\n        description=\"Answer addresses the question, 'yes' or 'no'\"\n    )\n\n\n# LLM with function call\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(GradeAnswer)\n\n# Prompt\nanswer_prompt = hub.pull(\"efriis/self-rag-answer-grader\")\n\nanswer_grader = answer_prompt | structured_llm_grader\nprint(question)\nprint(generation)\nanswer_grader.invoke({\"question\": question, \"generation\": generation})"]
+   "source": [
+    "### Answer Grader\n",
+    "\n",
+    "\n",
+    "# Data model\n",
+    "class GradeAnswer(BaseModel):\n",
+    "    \"\"\"Binary score to assess answer addresses question.\"\"\"\n",
+    "\n",
+    "    binary_score: str = Field(\n",
+    "        description=\"Answer addresses the question, 'yes' or 'no'\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# LLM with function call\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
+    "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n",
+    "\n",
+    "# Prompt\n",
+    "answer_prompt = hub.pull(\"efriis/self-rag-answer-grader\")\n",
+    "\n",
+    "answer_grader = answer_prompt | structured_llm_grader\n",
+    "print(question)\n",
+    "print(generation)\n",
+    "answer_grader.invoke({\"question\": question, \"generation\": generation})"
+   ]
   },
   {
    "cell_type": "code",
@@ -242,7 +328,9 @@
      "output_type": "execute_result"
     }
    ],
-   "source": ["### Question Re-writer\n\n# LLM\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n\n# Prompt\nre_write_prompt = hub.pull(\"efriis/self-rag-question-rewriter\")\n\nquestion_rewriter = re_write_prompt | llm | StrOutputParser()\nprint(question)\nquestion_rewriter.invoke({\"question\": question})"]
+   "source": [
+    "### Question Re-writer\n\n# LLM\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n\n# Prompt\nre_write_prompt = hub.pull(\"efriis/self-rag-question-rewriter\")\n\nquestion_rewriter = re_write_prompt | llm | StrOutputParser()\nprint(question)\nquestion_rewriter.invoke({\"question\": question})"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -262,7 +350,9 @@
    "id": "f1617e9e-66a8-4c1a-a1fe-cc936284c085",
    "metadata": {},
    "outputs": [],
-   "source": ["from typing import List\n\nfrom typing_extensions import TypedDict\n\n\nclass GraphState(TypedDict):\n    \"\"\"\n    Represents the state of our graph.\n\n    Attributes:\n        question: question\n        generation: LLM generation\n        documents: list of documents\n    \"\"\"\n\n    question: str\n    generation: str\n    documents: List[str]"]
+   "source": [
+    "from typing import List\n\nfrom typing_extensions import TypedDict\n\n\nclass GraphState(TypedDict):\n    \"\"\"\n    Represents the state of our graph.\n\n    Attributes:\n        question: question\n        generation: LLM generation\n        documents: list of documents\n    \"\"\"\n\n    question: str\n    generation: str\n    documents: List[str]"
+   ]
   },
   {
    "cell_type": "code",
@@ -270,7 +360,9 @@
    "id": "add509d8-6682-4127-8d95-13dd37d79702",
    "metadata": {},
    "outputs": [],
-   "source": ["### Nodes\n\n\ndef retrieve(state):\n    \"\"\"\n    Retrieve documents\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): New key added to state, documents, that contains retrieved documents\n    \"\"\"\n    print(\"---RETRIEVE---\")\n    question = state[\"question\"]\n\n    # Retrieval\n    documents = retriever.invoke(question)\n    return {\"documents\": documents, \"question\": question}\n\n\ndef generate(state):\n    \"\"\"\n    Generate answer\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): New key added to state, generation, that contains LLM generation\n    \"\"\"\n    print(\"---GENERATE---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # RAG generation\n    generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n    return {\"documents\": documents, \"question\": question, \"generation\": generation}\n\n\ndef grade_documents(state):\n    \"\"\"\n    Determines whether the retrieved documents are relevant to the question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): Updates documents key with only filtered relevant documents\n    \"\"\"\n\n    print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # Score each doc\n    filtered_docs = []\n    for d in documents:\n        score = retrieval_grader.invoke(\n            {\"question\": question, \"document\": d.page_content}\n        )\n        grade = score.binary_score\n        if grade == \"yes\":\n            print(\"---GRADE: DOCUMENT RELEVANT---\")\n            filtered_docs.append(d)\n        else:\n            print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n            continue\n    return {\"documents\": filtered_docs, \"question\": question}\n\n\ndef transform_query(state):\n    \"\"\"\n    Transform the query to produce a better question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): Updates question key with a re-phrased question\n    \"\"\"\n\n    print(\"---TRANSFORM QUERY---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # Re-write question\n    better_question = question_rewriter.invoke({\"question\": question})\n    return {\"documents\": documents, \"question\": better_question}"]
+   "source": [
+    "### Nodes\n\n\ndef retrieve(state):\n    \"\"\"\n    Retrieve documents\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): New key added to state, documents, that contains retrieved documents\n    \"\"\"\n    print(\"---RETRIEVE---\")\n    question = state[\"question\"]\n\n    # Retrieval\n    documents = retriever.invoke(question)\n    return {\"documents\": documents, \"question\": question}\n\n\ndef generate(state):\n    \"\"\"\n    Generate answer\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): New key added to state, generation, that contains LLM generation\n    \"\"\"\n    print(\"---GENERATE---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # RAG generation\n    generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n    return {\"documents\": documents, \"question\": question, \"generation\": generation}\n\n\ndef grade_documents(state):\n    \"\"\"\n    Determines whether the retrieved documents are relevant to the question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): Updates documents key with only filtered relevant documents\n    \"\"\"\n\n    print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # Score each doc\n    filtered_docs = []\n    for d in documents:\n        score = retrieval_grader.invoke(\n            {\"question\": question, \"document\": d.page_content}\n        )\n        grade = score.binary_score\n        if grade == \"yes\":\n            print(\"---GRADE: DOCUMENT RELEVANT---\")\n            filtered_docs.append(d)\n        else:\n            print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n            continue\n    return {\"documents\": filtered_docs, \"question\": question}\n\n\ndef transform_query(state):\n    \"\"\"\n    Transform the query to produce a better question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        state (dict): Updates question key with a re-phrased question\n    \"\"\"\n\n    print(\"---TRANSFORM QUERY---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n\n    # Re-write question\n    better_question = question_rewriter.invoke({\"question\": question})\n    return {\"documents\": documents, \"question\": better_question}"
+   ]
   },
   {
    "cell_type": "code",
@@ -278,7 +370,9 @@
    "id": "09fc91b4",
    "metadata": {},
    "outputs": [],
-   "source": ["### Edges\n\n\ndef decide_to_generate(state):\n    \"\"\"\n    Determines whether to generate an answer, or re-generate a question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        str: Binary decision for next node to call\n    \"\"\"\n\n    print(\"---ASSESS GRADED DOCUMENTS---\")\n    state[\"question\"]\n    filtered_documents = state[\"documents\"]\n\n    if not filtered_documents:\n        # All documents have been filtered check_relevance\n        # We will re-generate a new query\n        print(\n            \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n        )\n        return \"transform_query\"\n    else:\n        # We have relevant documents, so generate answer\n        print(\"---DECISION: GENERATE---\")\n        return \"generate\"\n\n\ndef grade_generation_v_documents_and_question(state):\n    \"\"\"\n    Determines whether the generation is grounded in the document and answers question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        str: Decision for next node to call\n    \"\"\"\n\n    print(\"---CHECK HALLUCINATIONS---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n    generation = state[\"generation\"]\n\n    score = hallucination_grader.invoke(\n        {\"documents\": documents, \"generation\": generation}\n    )\n    grade = score.binary_score\n\n    # Check hallucination\n    if grade == \"yes\":\n        print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n        # Check question-answering\n        print(\"---GRADE GENERATION vs QUESTION---\")\n        score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n        grade = score.binary_score\n        if grade == \"yes\":\n            print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n            return \"useful\"\n        else:\n            print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n            return \"not useful\"\n    else:\n        pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n        return \"not supported\""]
+   "source": [
+    "### Edges\n\n\ndef decide_to_generate(state):\n    \"\"\"\n    Determines whether to generate an answer, or re-generate a question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        str: Binary decision for next node to call\n    \"\"\"\n\n    print(\"---ASSESS GRADED DOCUMENTS---\")\n    state[\"question\"]\n    filtered_documents = state[\"documents\"]\n\n    if not filtered_documents:\n        # All documents have been filtered check_relevance\n        # We will re-generate a new query\n        print(\n            \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n        )\n        return \"transform_query\"\n    else:\n        # We have relevant documents, so generate answer\n        print(\"---DECISION: GENERATE---\")\n        return \"generate\"\n\n\ndef grade_generation_v_documents_and_question(state):\n    \"\"\"\n    Determines whether the generation is grounded in the document and answers question.\n\n    Args:\n        state (dict): The current graph state\n\n    Returns:\n        str: Decision for next node to call\n    \"\"\"\n\n    print(\"---CHECK HALLUCINATIONS---\")\n    question = state[\"question\"]\n    documents = state[\"documents\"]\n    generation = state[\"generation\"]\n\n    score = hallucination_grader.invoke(\n        {\"documents\": documents, \"generation\": generation}\n    )\n    grade = score.binary_score\n\n    # Check hallucination\n    if grade == \"yes\":\n        print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n        # Check question-answering\n        print(\"---GRADE GENERATION vs QUESTION---\")\n        score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n        grade = score.binary_score\n        if grade == \"yes\":\n            print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n            return \"useful\"\n        else:\n            print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n            return \"not useful\"\n    else:\n        pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n        return \"not supported\""
+   ]
   },
   {
    "cell_type": "markdown",
@@ -331,7 +425,9 @@
      ]
     }
    ],
-   "source": ["from pprint import pprint\n\n# Run\ninputs = {\"question\": \"Movies that star Daniel Craig\"}\nfor output in app.stream(inputs):\n    for key, value in output.items():\n        # Node\n        pprint(f\"Node '{key}':\")\n    pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])"]
+   "source": [
+    "from pprint import pprint\n\n# Run\ninputs = {\"question\": \"Movies that star Daniel Craig\"}\nfor output in app.stream(inputs):\n    for key, value in output.items():\n        # Node\n        pprint(f\"Node '{key}':\")\n    pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])"
+   ]
   },
   {
    "cell_type": "code",
@@ -339,7 +435,9 @@
    "id": "4138bc51-8c84-4b8a-8d24-f7f470721f6f",
    "metadata": {},
    "outputs": [],
-   "source": ["inputs = {\"question\": \"Which movies are about aliens?\"}\nfor output in app.stream(inputs):\n    for key, value in output.items():\n        # Node\n        pprint(f\"Node '{key}':\")\n    pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])"]
+   "source": [
+    "inputs = {\"question\": \"Which movies are about aliens?\"}\nfor output in app.stream(inputs):\n    for key, value in output.items():\n        # Node\n        pprint(f\"Node '{key}':\")\n    pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])"
+   ]
   },
   {
    "cell_type": "code",
@@ -347,7 +445,9 @@
    "id": "42369ab8-322d-434a-b5dd-2266e4cb2903",
    "metadata": {},
    "outputs": [],
-   "source": [""]
+   "source": [
+    ""
+   ]
   }
  ],
  "metadata": {

libs/checkpoint-postgres/README.md

@@ -13,6 +13,20 @@ By default `langgraph-checkpoint-postgres` installs `psycopg` (Psycopg 3) withou
 
 > [!IMPORTANT]
 > When manually creating Postgres connections and passing them to `PostgresSaver` or `AsyncPostgresSaver`, make sure to include `autocommit=True` and `row_factory=dict_row` (`from psycopg.rows import dict_row`). See a full example in this [how-to guide](https://langchain-ai.github.io/langgraph/how-tos/persistence_postgres/).
+>
+> **Why these parameters are required:**
+> - `autocommit=True`: Required for the `.setup()` method to properly commit the checkpoint tables to the database. Without this, table creation may not be persisted.
+> - `row_factory=dict_row`: Required because the PostgresSaver implementation accesses database rows using dictionary-style syntax (e.g., `row["column_name"]`). The default `tuple_row` factory returns tuples that only support index-based access (e.g., `row[0]`), which will cause `TypeError` exceptions when the checkpointer tries to access columns by name.
+>
+> **Example of incorrect usage:**
+> ```python
+> # ❌ This will fail with TypeError during checkpointer operations
+> with psycopg.connect(DB_URI) as conn:  # Missing autocommit=True and row_factory=dict_row
+>     checkpointer = PostgresSaver(conn)
+>     checkpointer.setup()  # May not persist tables properly
+>     # Any operation that reads from database will fail with:
+>     # TypeError: tuple indices must be integers or slices, not str
+> ```
 
 ```python
 from langgraph.checkpoint.postgres import PostgresSaver

libs/checkpoint-postgres/langgraph/checkpoint/postgres/__init__.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import threading
 from collections import defaultdict
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
-from typing import Any, Optional
+from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 from psycopg import Capabilities, Connection, Cursor, Pipeline
@@ -34,8 +36,8 @@ class PostgresSaver(BasePostgresSaver):
     def __init__(
         self,
         conn: _internal.Conn,
-        pipe: Optional[Pipeline] = None,
-        serde: Optional[SerializerProtocol] = None,
+        pipe: Pipeline | None = None,
+        serde: SerializerProtocol | None = None,
     ) -> None:
         super().__init__(serde=serde)
         if isinstance(conn, ConnectionPool) and pipe is not None:
@@ -52,7 +54,7 @@ class PostgresSaver(BasePostgresSaver):
     @contextmanager
     def from_conn_string(
         cls, conn_string: str, *, pipeline: bool = False
-    ) -> Iterator["PostgresSaver"]:
+    ) -> Iterator[PostgresSaver]:
         """Create a new PostgresSaver instance from a connection string.
 
         Args:
@@ -99,11 +101,11 @@ class PostgresSaver(BasePostgresSaver):
 
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints from the database.
 
@@ -173,34 +175,9 @@ class PostgresSaver(BasePostgresSaver):
                             value["channel_values"],
                         )
             for value in values:
-                yield CheckpointTuple(
-                    {
-                        "configurable": {
-                            "thread_id": value["thread_id"],
-                            "checkpoint_ns": value["checkpoint_ns"],
-                            "checkpoint_id": value["checkpoint_id"],
-                        }
-                    },
-                    {
-                        **value["checkpoint"],
-                        "channel_values": self._load_blobs(value["channel_values"]),
-                    },
-                    value["metadata"],
-                    (
-                        {
-                            "configurable": {
-                                "thread_id": value["thread_id"],
-                                "checkpoint_ns": value["checkpoint_ns"],
-                                "checkpoint_id": value["parent_checkpoint_id"],
-                            }
-                        }
-                        if value["parent_checkpoint_id"]
-                        else None
-                    ),
-                    self._load_writes(value["pending_writes"]),
-                )
+                yield self._load_checkpoint_tuple(value)
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database.
 
         This method retrieves a checkpoint tuple from the Postgres database based on the
@@ -269,32 +246,7 @@ class PostgresSaver(BasePostgresSaver):
                         value["channel_values"],
                     )
 
-            return CheckpointTuple(
-                {
-                    "configurable": {
-                        "thread_id": thread_id,
-                        "checkpoint_ns": checkpoint_ns,
-                        "checkpoint_id": value["checkpoint_id"],
-                    }
-                },
-                {
-                    **value["checkpoint"],
-                    "channel_values": self._load_blobs(value["channel_values"]),
-                },
-                value["metadata"],
-                (
-                    {
-                        "configurable": {
-                            "thread_id": thread_id,
-                            "checkpoint_ns": checkpoint_ns,
-                            "checkpoint_id": value["parent_checkpoint_id"],
-                        }
-                    }
-                    if value["parent_checkpoint_id"]
-                    else None
-                ),
-                self._load_writes(value["pending_writes"]),
-            )
+            return self._load_checkpoint_tuple(value)
 
     def put(
         self,
@@ -464,5 +416,44 @@ class PostgresSaver(BasePostgresSaver):
                 with conn.cursor(binary=True, row_factory=dict_row) as cur:
                     yield cur
 
+    def _load_checkpoint_tuple(self, value: DictRow) -> CheckpointTuple:
+        """
+        Convert a database row into a CheckpointTuple object.
+
+        Args:
+            value: A row from the database containing checkpoint data.
+
+        Returns:
+            CheckpointTuple: A structured representation of the checkpoint,
+            including its configuration, metadata, parent checkpoint (if any),
+            and pending writes.
+        """
+        return CheckpointTuple(
+            {
+                "configurable": {
+                    "thread_id": value["thread_id"],
+                    "checkpoint_ns": value["checkpoint_ns"],
+                    "checkpoint_id": value["checkpoint_id"],
+                }
+            },
+            {
+                **value["checkpoint"],
+                "channel_values": self._load_blobs(value["channel_values"]),
+            },
+            value["metadata"],
+            (
+                {
+                    "configurable": {
+                        "thread_id": value["thread_id"],
+                        "checkpoint_ns": value["checkpoint_ns"],
+                        "checkpoint_id": value["parent_checkpoint_id"],
+                    }
+                }
+                if value["parent_checkpoint_id"]
+                else None
+            ),
+            self._load_writes(value["pending_writes"]),
+        )
+
 
 __all__ = ["PostgresSaver", "BasePostgresSaver", "Conn"]

libs/checkpoint-postgres/langgraph/checkpoint/postgres/aio.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 from psycopg import AsyncConnection, AsyncCursor, AsyncPipeline, Capabilities
@@ -34,8 +36,8 @@ class AsyncPostgresSaver(BasePostgresSaver):
     def __init__(
         self,
         conn: _ainternal.Conn,
-        pipe: Optional[AsyncPipeline] = None,
-        serde: Optional[SerializerProtocol] = None,
+        pipe: AsyncPipeline | None = None,
+        serde: SerializerProtocol | None = None,
     ) -> None:
         super().__init__(serde=serde)
         if isinstance(conn, AsyncConnectionPool) and pipe is not None:
@@ -56,8 +58,8 @@ class AsyncPostgresSaver(BasePostgresSaver):
         conn_string: str,
         *,
         pipeline: bool = False,
-        serde: Optional[SerializerProtocol] = None,
-    ) -> AsyncIterator["AsyncPostgresSaver"]:
+        serde: SerializerProtocol | None = None,
+    ) -> AsyncIterator[AsyncPostgresSaver]:
         """Create a new AsyncPostgresSaver instance from a connection string.
 
         Args:
@@ -104,11 +106,11 @@ class AsyncPostgresSaver(BasePostgresSaver):
 
     async def alist(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[CheckpointTuple]:
         """List checkpoints from the database asynchronously.
 
@@ -160,34 +162,9 @@ class AsyncPostgresSaver(BasePostgresSaver):
                             value["channel_values"],
                         )
             for value in values:
-                yield CheckpointTuple(
-                    {
-                        "configurable": {
-                            "thread_id": value["thread_id"],
-                            "checkpoint_ns": value["checkpoint_ns"],
-                            "checkpoint_id": value["checkpoint_id"],
-                        }
-                    },
-                    {
-                        **value["checkpoint"],
-                        "channel_values": self._load_blobs(value["channel_values"]),
-                    },
-                    value["metadata"],
-                    (
-                        {
-                            "configurable": {
-                                "thread_id": value["thread_id"],
-                                "checkpoint_ns": value["checkpoint_ns"],
-                                "checkpoint_id": value["parent_checkpoint_id"],
-                            }
-                        }
-                        if value["parent_checkpoint_id"]
-                        else None
-                    ),
-                    await asyncio.to_thread(self._load_writes, value["pending_writes"]),
-                )
+                yield await self._load_checkpoint_tuple(value)
 
-    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database asynchronously.
 
         This method retrieves a checkpoint tuple from the Postgres database based on the
@@ -236,32 +213,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
                         value["channel_values"],
                     )
 
-            return CheckpointTuple(
-                {
-                    "configurable": {
-                        "thread_id": thread_id,
-                        "checkpoint_ns": checkpoint_ns,
-                        "checkpoint_id": value["checkpoint_id"],
-                    }
-                },
-                {
-                    **value["checkpoint"],
-                    "channel_values": self._load_blobs(value["channel_values"]),
-                },
-                value["metadata"],
-                (
-                    {
-                        "configurable": {
-                            "thread_id": thread_id,
-                            "checkpoint_ns": checkpoint_ns,
-                            "checkpoint_id": value["parent_checkpoint_id"],
-                        }
-                    }
-                    if value["parent_checkpoint_id"]
-                    else None
-                ),
-                await asyncio.to_thread(self._load_writes, value["pending_writes"]),
-            )
+            return await self._load_checkpoint_tuple(value)
 
     async def aput(
         self,
@@ -422,13 +374,52 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 async with conn.cursor(binary=True, row_factory=dict_row) as cur:
                     yield cur
 
+    async def _load_checkpoint_tuple(self, value: DictRow) -> CheckpointTuple:
+        """
+        Convert a database row into a CheckpointTuple object.
+
+        Args:
+            value: A row from the database containing checkpoint data.
+
+        Returns:
+            CheckpointTuple: A structured representation of the checkpoint,
+            including its configuration, metadata, parent checkpoint (if any),
+            and pending writes.
+        """
+        return CheckpointTuple(
+            {
+                "configurable": {
+                    "thread_id": value["thread_id"],
+                    "checkpoint_ns": value["checkpoint_ns"],
+                    "checkpoint_id": value["checkpoint_id"],
+                }
+            },
+            {
+                **value["checkpoint"],
+                "channel_values": self._load_blobs(value["channel_values"]),
+            },
+            value["metadata"],
+            (
+                {
+                    "configurable": {
+                        "thread_id": value["thread_id"],
+                        "checkpoint_ns": value["checkpoint_ns"],
+                        "checkpoint_id": value["parent_checkpoint_id"],
+                    }
+                }
+                if value["parent_checkpoint_id"]
+                else None
+            ),
+            await asyncio.to_thread(self._load_writes, value["pending_writes"]),
+        )
+
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints from the database.
 
@@ -466,7 +457,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
             except StopAsyncIteration:
                 break
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database.
 
         This method retrieves a checkpoint tuple from the Postgres database based on the

libs/checkpoint-postgres/langgraph/checkpoint/postgres/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import random
 from collections.abc import Sequence
 from typing import Any, Optional, cast
@@ -186,7 +188,7 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
         checkpoint_ns: str,
         values: dict[str, Any],
         versions: ChannelVersions,
-    ) -> list[tuple[str, str, str, str, str, Optional[bytes]]]:
+    ) -> list[tuple[str, str, str, str, str, bytes | None]]:
         if not versions:
             return []
 
@@ -244,7 +246,7 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
             for idx, (channel, value) in enumerate(writes)
         ]
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: str | None) -> str:
         if current is None:
             current_v = 0
         elif isinstance(current, int):
@@ -257,9 +259,9 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
 
     def _search_where(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         filter: MetadataInput,
-        before: Optional[RunnableConfig] = None,
+        before: RunnableConfig | None = None,
     ) -> tuple[str, list[Any]]:
         """Return WHERE clause predicates for alist() given config, filter, before.
 

libs/checkpoint-postgres/langgraph/store/postgres/aio.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 from collections.abc import AsyncIterator, Iterable, Sequence
 from contextlib import asynccontextmanager
 from types import TracebackType
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Callable, cast
 
 import orjson
 from psycopg import AsyncConnection, AsyncCursor, AsyncPipeline, Capabilities
@@ -132,12 +134,10 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         self,
         conn: _ainternal.Conn,
         *,
-        pipe: Optional[AsyncPipeline] = None,
-        deserializer: Optional[
-            Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
-        ] = None,
-        index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
+        pipe: AsyncPipeline | None = None,
+        deserializer: Callable[[bytes | orjson.Fragment], dict[str, Any]] | None = None,
+        index: PostgresIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
     ) -> None:
         if isinstance(conn, AsyncConnectionPool) and pipe is not None:
             raise ValueError(
@@ -157,7 +157,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
             self.embeddings = None
 
         self.ttl_config = ttl
-        self._ttl_sweeper_task: Optional[asyncio.Task[None]] = None
+        self._ttl_sweeper_task: asyncio.Task[None] | None = None
         self._ttl_stop_event = asyncio.Event()
 
     async def abatch(self, ops: Iterable[Op]) -> list[Result]:
@@ -180,10 +180,10 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         conn_string: str,
         *,
         pipeline: bool = False,
-        pool_config: Optional[PoolConfig] = None,
-        index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ) -> AsyncIterator["AsyncPostgresStore"]:
+        pool_config: PoolConfig | None = None,
+        index: PostgresIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
+    ) -> AsyncIterator[AsyncPostgresStore]:
         """Create a new AsyncPostgresStore instance from a connection string.
 
         Args:
@@ -289,7 +289,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
             return deleted_count
 
     async def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
+        self, sweep_interval_minutes: int | None = None
     ) -> asyncio.Task[None]:
         """Periodically delete expired store items based on TTL.
 
@@ -334,7 +334,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         self._ttl_sweeper_task = task
         return task
 
-    async def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
+    async def stop_ttl_sweeper(self, timeout: float | None = None) -> bool:
         """Stop the TTL sweeper task if it's running.
 
         Args:
@@ -369,14 +369,14 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
 
         return success
 
-    async def __aenter__(self) -> "AsyncPostgresStore":
+    async def __aenter__(self) -> AsyncPostgresStore:
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional["TracebackType"],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         # Ensure the TTL sweeper task is stopped when exiting the context
         if hasattr(self, "_ttl_sweeper_task") and self._ttl_sweeper_task is not None:

libs/checkpoint-postgres/langgraph/store/postgres/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import concurrent.futures
 import json
@@ -14,7 +16,6 @@ from typing import (
     Generic,
     Literal,
     NamedTuple,
-    Optional,
     TypeVar,
     Union,
     cast,
@@ -56,8 +57,8 @@ class Migration(NamedTuple):
     """A database migration with optional conditions and parameters."""
 
     sql: str
-    params: Optional[dict[str, Any]] = None
-    condition: Optional[Callable[["BasePostgresStore"], bool]] = None
+    params: dict[str, Any] | None = None
+    condition: Callable[[BasePostgresStore], bool] | None = None
 
 
 MIGRATIONS: Sequence[str] = [
@@ -155,7 +156,7 @@ class PoolConfig(TypedDict, total=False):
     min_size: int
     """Minimum number of connections maintained in the pool. Defaults to 1."""
 
-    max_size: Optional[int]
+    max_size: int | None
     """Maximum number of connections allowed in the pool. None means unlimited."""
 
     kwargs: dict
@@ -230,8 +231,8 @@ class BasePostgresStore(Generic[C]):
     MIGRATIONS = MIGRATIONS
     VECTOR_MIGRATIONS = VECTOR_MIGRATIONS
     conn: C
-    _deserializer: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]]
-    index_config: Optional[PostgresIndexConfig]
+    _deserializer: Callable[[bytes | orjson.Fragment], dict[str, Any]] | None
+    index_config: PostgresIndexConfig | None
 
     def _get_batch_GET_ops_queries(
         self,
@@ -293,7 +294,7 @@ class BasePostgresStore(Generic[C]):
         put_ops: Sequence[tuple[int, PutOp]],
     ) -> tuple[
         list[tuple[str, Sequence]],
-        Optional[tuple[str, Sequence[tuple[str, str, str, str]]]],
+        tuple[str, Sequence[tuple[str, str, str, str]]] | None,
     ]:
         dedupped_ops: dict[tuple[tuple[str, ...], str], PutOp] = {}
         for _, op in put_ops:
@@ -320,9 +321,7 @@ class BasePostgresStore(Generic[C]):
                 )
                 params = (_namespace_to_text(namespace), *keys)
                 queries.append((query, params))
-        embedding_request: Optional[tuple[str, Sequence[tuple[str, str, str, str]]]] = (
-            None
-        )
+        embedding_request: tuple[str, Sequence[tuple[str, str, str, str]]] | None = None
         if inserts:
             values = []
             insertion_params = []
@@ -403,7 +402,7 @@ class BasePostgresStore(Generic[C]):
         self,
         search_ops: Sequence[tuple[int, SearchOp]],
     ) -> tuple[
-        list[tuple[str, list[Union[None, str, list[float]]]]],  # queries, params
+        list[tuple[str, list[None | str | list[float]]]],  # queries, params
         list[tuple[int, str]],  # idx, query_text pairs to embed
     ]:
         """
@@ -432,7 +431,7 @@ class BasePostgresStore(Generic[C]):
                         filter_params.extend([key, orjson.dumps(value).decode("utf-8")])
 
             ns_condition = "TRUE"
-            ns_param: Optional[Sequence[Union[str]]] = None
+            ns_param: Sequence[str] | None = None
             if op.namespace_prefix:
                 ns_condition = "store.prefix LIKE %s"
                 ns_param = (f"{_namespace_to_text(op.namespace_prefix)}%",)
@@ -719,12 +718,10 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         self,
         conn: _pg_internal.Conn,
         *,
-        pipe: Optional[Pipeline] = None,
-        deserializer: Optional[
-            Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
-        ] = None,
-        index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
+        pipe: Pipeline | None = None,
+        deserializer: Callable[[bytes | orjson.Fragment], dict[str, Any]] | None = None,
+        index: PostgresIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
     ) -> None:
         super().__init__()
         self._deserializer = deserializer
@@ -738,7 +735,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         else:
             self.embeddings = None
         self.ttl_config = ttl
-        self._ttl_sweeper_thread: Optional[threading.Thread] = None
+        self._ttl_sweeper_thread: threading.Thread | None = None
         self._ttl_stop_event = threading.Event()
 
     @classmethod
@@ -748,10 +745,10 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         conn_string: str,
         *,
         pipeline: bool = False,
-        pool_config: Optional[PoolConfig] = None,
-        index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ) -> Iterator["PostgresStore"]:
+        pool_config: PoolConfig | None = None,
+        index: PostgresIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
+    ) -> Iterator[PostgresStore]:
         """Create a new PostgresStore instance from a connection string.
 
         Args:
@@ -810,7 +807,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
             return deleted_count
 
     def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
+        self, sweep_interval_minutes: int | None = None
     ) -> concurrent.futures.Future[None]:
         """Periodically delete expired store items based on TTL.
 
@@ -867,7 +864,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         )
         return future
 
-    def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
+    def stop_ttl_sweeper(self, timeout: float | None = None) -> bool:
         """Stop the TTL sweeper thread if it's running.
 
         Args:
@@ -1196,7 +1193,7 @@ def _row_to_item(
     namespace: tuple[str, ...],
     row: Row,
     *,
-    loader: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]] = None,
+    loader: Callable[[bytes | orjson.Fragment], dict[str, Any]] | None = None,
 ) -> Item:
     """Convert a row from the database into an Item.
 
@@ -1224,7 +1221,7 @@ def _row_to_search_item(
     namespace: tuple[str, ...],
     row: Row,
     *,
-    loader: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]] = None,
+    loader: Callable[[bytes | orjson.Fragment], dict[str, Any]] | None = None,
 ) -> SearchItem:
     """Convert a row from the database into an Item."""
     loader = loader or _json_loads
@@ -1255,7 +1252,7 @@ def _group_ops(ops: Iterable[Op]) -> tuple[dict[type, list[tuple[int, Op]]], int
     return grouped_ops, tot
 
 
-def _json_loads(content: Union[bytes, orjson.Fragment]) -> Any:
+def _json_loads(content: bytes | orjson.Fragment) -> Any:
     if isinstance(content, orjson.Fragment):
         if hasattr(content, "buf"):
             content = content.buf
@@ -1267,7 +1264,7 @@ def _json_loads(content: Union[bytes, orjson.Fragment]) -> Any:
     return orjson.loads(cast(bytes, content))
 
 
-def _decode_ns_bytes(namespace: Union[str, bytes, list]) -> tuple[str, ...]:
+def _decode_ns_bytes(namespace: str | bytes | list) -> tuple[str, ...]:
     if isinstance(namespace, list):
         return tuple(namespace)
     if isinstance(namespace, bytes):
@@ -1316,16 +1313,16 @@ def get_distance_operator(store: Any) -> tuple[str, str]:
 
 def _ensure_index_config(
     index_config: PostgresIndexConfig,
-) -> tuple[Optional["Embeddings"], PostgresIndexConfig]:
+) -> tuple[Embeddings | None, PostgresIndexConfig]:
     index_config = index_config.copy()
-    tokenized: list[tuple[str, Union[Literal["$"], list[str]]]] = []
+    tokenized: list[tuple[str, Literal["$"] | list[str]]] = []
     tot = 0
-    text_fields = index_config.get("fields") or ["$"]
-    if isinstance(text_fields, str):
-        text_fields = [text_fields]
-    if not isinstance(text_fields, list):
-        raise ValueError(f"Text fields must be a list or a string. Got {text_fields}")
-    for p in text_fields:
+    fields = index_config.get("fields") or ["$"]
+    if isinstance(fields, str):
+        fields = [fields]
+    if not isinstance(fields, list):
+        raise ValueError(f"Text fields must be a list or a string. Got {fields}")
+    for p in fields:
         if p == "$":
             tokenized.append((p, "$"))
             tot += 1

libs/checkpoint-postgres/pyproject.toml

@@ -56,7 +56,7 @@ lint.select = [
   "B",  # flake8-bugbear
   "I",  # isort
 ]
-lint.ignore = ["E501", "B008", "UP007", "UP006"]
+lint.ignore = ["E501", "B008"]
 
 [tool.mypy]
 # https://mypy.readthedocs.io/en/stable/config_file.html

libs/checkpoint-postgres/tests/checkpoint_utils.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
+from typing import Any, Protocol
 
 from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
 from langgraph.checkpoint.base.id import uuid6
 
 
 class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
+    def checkpoint(self) -> Any | None: ...
 
 
 def empty_checkpoint() -> Checkpoint:
@@ -23,10 +25,10 @@ def empty_checkpoint() -> Checkpoint:
 
 def create_checkpoint(
     checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
+    channels: Mapping[str, ChannelProtocol] | None,
     step: int,
     *,
-    id: Optional[str] = None,
+    id: str | None = None,
 ) -> Checkpoint:
     """Create a checkpoint for the given channels."""
     ts = datetime.now(timezone.utc).isoformat()

libs/checkpoint-postgres/tests/test_async_store.py

@@ -1,4 +1,6 @@
 # type: ignore
+from __future__ import annotations
+
 import asyncio
 import itertools
 import sys
@@ -6,7 +8,7 @@ import uuid
 from collections.abc import AsyncIterator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from langchain_core.embeddings import Embeddings
@@ -353,7 +355,7 @@ async def _create_vector_store(
     vector_type: str,
     distance_type: str,
     fake_embeddings: CharacterEmbeddings,
-    text_fields: Optional[list[str]] = None,
+    text_fields: list[str] | None = None,
 ) -> AsyncIterator[AsyncPostgresStore]:
     """Create a store with vector search enabled."""
     if sys.version_info < (3, 10):

libs/checkpoint-postgres/tests/test_store.py

@@ -1,9 +1,10 @@
 # type: ignore
+from __future__ import annotations
 
 import re
 import time
 from contextlib import contextmanager
-from typing import Any, Optional
+from typing import Any
 from uuid import uuid4
 
 import pytest
@@ -379,7 +380,7 @@ def _create_vector_store(
     vector_type: str,
     distance_type: str,
     fake_embeddings: Embeddings,
-    text_fields: Optional[list[str]] = None,
+    text_fields: list[str] | None = None,
     enable_ttl: bool = True,
 ) -> PostgresStore:
     """Create a store with vector search enabled."""

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/__init__.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 import random
 import sqlite3
 import threading
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import closing, contextmanager
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 from langchain_core.runnables import RunnableConfig
 
@@ -76,7 +78,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
         self,
         conn: sqlite3.Connection,
         *,
-        serde: Optional[SerializerProtocol] = None,
+        serde: SerializerProtocol | None = None,
     ) -> None:
         super().__init__(serde=serde)
         self.jsonplus_serde = JsonPlusSerializer()
@@ -86,7 +88,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
 
     @classmethod
     @contextmanager
-    def from_conn_string(cls, conn_string: str) -> Iterator["SqliteSaver"]:
+    def from_conn_string(cls, conn_string: str) -> Iterator[SqliteSaver]:
         """Create a new SqliteSaver instance from a connection string.
 
         Args:
@@ -178,7 +180,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                     self.conn.commit()
                 cur.close()
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database.
 
         This method retrieves a checkpoint tuple from the SQLite database based on the
@@ -286,11 +288,11 @@ class SqliteSaver(BaseCheckpointSaver[str]):
 
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints from the database.
 
@@ -493,7 +495,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                 (str(thread_id),),
             )
 
-    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database asynchronously.
 
         Note:
@@ -504,11 +506,11 @@ class SqliteSaver(BaseCheckpointSaver[str]):
 
     async def alist(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[CheckpointTuple]:
         """List checkpoints from the database asynchronously.
 
@@ -534,7 +536,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
         """
         raise NotImplementedError(_AIO_ERROR_MSG)
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: str | None) -> str:
         """Generate the next version ID for a channel.
 
         This method creates a new version identifier for a channel based on its current version.

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/aio.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 import random
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
-from typing import Any, Callable, Optional, TypeVar, cast
+from typing import Any, Callable, TypeVar, cast
 
 import aiosqlite
 from langchain_core.runnables import RunnableConfig
@@ -108,7 +110,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
         self,
         conn: aiosqlite.Connection,
         *,
-        serde: Optional[SerializerProtocol] = None,
+        serde: SerializerProtocol | None = None,
     ):
         super().__init__(serde=serde)
         self.jsonplus_serde = JsonPlusSerializer()
@@ -121,7 +123,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
     @asynccontextmanager
     async def from_conn_string(
         cls, conn_string: str
-    ) -> AsyncIterator["AsyncSqliteSaver"]:
+    ) -> AsyncIterator[AsyncSqliteSaver]:
         """Create a new AsyncSqliteSaver instance from a connection string.
 
         Args:
@@ -133,7 +135,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
         async with aiosqlite.connect(conn_string) as conn:
             yield cls(conn)
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database.
 
         This method retrieves a checkpoint tuple from the SQLite database based on the
@@ -165,11 +167,11 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
 
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints from the database asynchronously.
 
@@ -310,7 +312,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
 
             self.is_setup = True
 
-    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the database asynchronously.
 
         This method retrieves a checkpoint tuple from the SQLite database based on the
@@ -398,11 +400,11 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
 
     async def alist(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[CheckpointTuple]:
         """List checkpoints from the database asynchronously.
 
@@ -589,7 +591,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             )
             await self.conn.commit()
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: str | None) -> str:
         """Generate the next version ID for a channel.
 
         This method creates a new version identifier for a channel based on its current version.

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/utils.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import json
 from collections.abc import Sequence
-from typing import Any, Optional
+from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 
@@ -52,9 +54,9 @@ def _metadata_predicate(
 
 
 def search_where(
-    config: Optional[RunnableConfig],
-    filter: Optional[dict[str, Any]],
-    before: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None,
+    filter: dict[str, Any] | None,
+    before: RunnableConfig | None = None,
 ) -> tuple[str, Sequence[Any]]:
     """Return WHERE clause predicates for (a)search() given metadata filter
     and `before` config.

libs/checkpoint-sqlite/langgraph/store/sqlite/aio.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Sequence
 from contextlib import asynccontextmanager
 from types import TracebackType
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Callable, cast
 
 import aiosqlite
 import orjson
@@ -88,11 +90,10 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
         self,
         conn: aiosqlite.Connection,
         *,
-        deserializer: Optional[
-            Callable[[Union[bytes, str, orjson.Fragment]], dict[str, Any]]
-        ] = None,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
+        deserializer: Callable[[bytes | str | orjson.Fragment], dict[str, Any]]
+        | None = None,
+        index: SqliteIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
     ):
         """Initialize the async SQLite store.
 
@@ -114,7 +115,7 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
         else:
             self.embeddings = None
         self.ttl_config = ttl
-        self._ttl_sweeper_task: Optional[asyncio.Task[None]] = None
+        self._ttl_sweeper_task: asyncio.Task[None] | None = None
         self._ttl_stop_event = asyncio.Event()
 
     @classmethod
@@ -123,9 +124,9 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
         cls,
         conn_string: str,
         *,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ) -> AsyncIterator["AsyncSqliteStore"]:
+        index: SqliteIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
+    ) -> AsyncIterator[AsyncSqliteStore]:
         """Create a new AsyncSqliteStore instance from a connection string.
 
         Args:
@@ -253,7 +254,7 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
             return deleted_count
 
     async def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
+        self, sweep_interval_minutes: int | None = None
     ) -> asyncio.Task[None]:
         """Periodically delete expired store items based on TTL.
 
@@ -298,7 +299,7 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
         self._ttl_sweeper_task = task
         return task
 
-    async def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
+    async def stop_ttl_sweeper(self, timeout: float | None = None) -> bool:
         """Stop the TTL sweeper task if it's running.
 
         Args:
@@ -333,14 +334,14 @@ class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
 
         return success
 
-    async def __aenter__(self) -> "AsyncSqliteStore":
+    async def __aenter__(self) -> AsyncSqliteStore:
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional["TracebackType"],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         # Ensure the TTL sweeper task is stopped when exiting the context
         if hasattr(self, "_ttl_sweeper_task") and self._ttl_sweeper_task is not None:

libs/checkpoint-sqlite/langgraph/store/sqlite/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import concurrent.futures
 import datetime
 import logging
@@ -6,7 +8,7 @@ import threading
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
-from typing import Any, Callable, Literal, NamedTuple, Optional, Union, cast
+from typing import Any, Callable, Literal, NamedTuple, cast
 
 import orjson
 import sqlite_vec  # type: ignore[import-untyped]
@@ -105,7 +107,7 @@ def _decode_ns_text(namespace: str) -> tuple[str, ...]:
     return tuple(namespace.split("."))
 
 
-def _json_loads(content: Union[bytes, str, orjson.Fragment]) -> Any:
+def _json_loads(content: bytes | str | orjson.Fragment) -> Any:
     if isinstance(content, orjson.Fragment):
         if hasattr(content, "buf"):
             content = content.buf
@@ -125,9 +127,7 @@ def _row_to_item(
     namespace: tuple[str, ...],
     row: dict[str, Any],
     *,
-    loader: Optional[
-        Callable[[Union[bytes, str, orjson.Fragment]], dict[str, Any]]
-    ] = None,
+    loader: Callable[[bytes | str | orjson.Fragment], dict[str, Any]] | None = None,
 ) -> Item:
     """Convert a row from the database into an Item."""
     val = row["value"]
@@ -149,9 +149,7 @@ def _row_to_search_item(
     namespace: tuple[str, ...],
     row: dict[str, Any],
     *,
-    loader: Optional[
-        Callable[[Union[bytes, str, orjson.Fragment]], dict[str, Any]]
-    ] = None,
+    loader: Callable[[bytes | str | orjson.Fragment], dict[str, Any]] | None = None,
 ) -> SearchItem:
     """Convert a row from the database into a SearchItem."""
     loader = loader or _json_loads
@@ -196,8 +194,8 @@ class BaseSqliteStore:
     MIGRATIONS = MIGRATIONS
     VECTOR_MIGRATIONS = VECTOR_MIGRATIONS
     supports_ttl = True
-    index_config: Optional[SqliteIndexConfig] = None
-    ttl_config: Optional[TTLConfig] = None
+    index_config: SqliteIndexConfig | None = None
+    ttl_config: TTLConfig | None = None
 
     def _get_batch_GET_ops_queries(
         self, get_ops: Sequence[tuple[int, GetOp]]
@@ -259,7 +257,7 @@ class BaseSqliteStore:
         self, put_ops: Sequence[tuple[int, PutOp]]
     ) -> tuple[
         list[tuple[str, Sequence]],
-        Optional[tuple[str, Sequence[tuple[str, str, str, str]]]],
+        tuple[str, Sequence[tuple[str, str, str, str]]] | None,
     ]:
         # Last-write wins
         dedupped_ops: dict[tuple[tuple[str, ...], str], PutOp] = {}
@@ -288,9 +286,7 @@ class BaseSqliteStore:
                 params = (_namespace_to_text(namespace), *keys)
                 queries.append((query, params))
 
-        embedding_request: Optional[tuple[str, Sequence[tuple[str, str, str, str]]]] = (
-            None
-        )
+        embedding_request: tuple[str, Sequence[tuple[str, str, str, str]]] | None = None
         if inserts:
             values = []
             insertion_params = []
@@ -358,7 +354,7 @@ class BaseSqliteStore:
     def _prepare_batch_search_queries(
         self, search_ops: Sequence[tuple[int, SearchOp]]
     ) -> tuple[
-        list[tuple[str, list[Union[None, str, list[float]]]]],  # queries, params
+        list[tuple[str, list[None | str | list[float]]]],  # queries, params
         list[tuple[int, str]],  # idx, query_text pairs to embed
     ]:
         """
@@ -785,11 +781,10 @@ class SqliteStore(BaseSqliteStore, BaseStore):
         self,
         conn: sqlite3.Connection,
         *,
-        deserializer: Optional[
-            Callable[[Union[bytes, str, orjson.Fragment]], dict[str, Any]]
-        ] = None,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
+        deserializer: Callable[[bytes | str | orjson.Fragment], dict[str, Any]]
+        | None = None,
+        index: SqliteIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
     ):
         super().__init__()
         self._deserializer = deserializer
@@ -802,7 +797,7 @@ class SqliteStore(BaseSqliteStore, BaseStore):
         else:
             self.embeddings = None
         self.ttl_config = ttl
-        self._ttl_sweeper_thread: Optional[threading.Thread] = None
+        self._ttl_sweeper_thread: threading.Thread | None = None
         self._ttl_stop_event = threading.Event()
 
     def _get_batch_GET_ops_queries(
@@ -956,9 +951,9 @@ class SqliteStore(BaseSqliteStore, BaseStore):
         cls,
         conn_string: str,
         *,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ) -> Iterator["SqliteStore"]:
+        index: SqliteIndexConfig | None = None,
+        ttl: TTLConfig | None = None,
+    ) -> Iterator[SqliteStore]:
         """Create a new SqliteStore instance from a connection string.
 
         Args:
@@ -1087,7 +1082,7 @@ class SqliteStore(BaseSqliteStore, BaseStore):
             return deleted_count
 
     def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
+        self, sweep_interval_minutes: int | None = None
     ) -> concurrent.futures.Future[None]:
         """Periodically delete expired store items based on TTL.
 
@@ -1144,7 +1139,7 @@ class SqliteStore(BaseSqliteStore, BaseStore):
         )
         return future
 
-    def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
+    def stop_ttl_sweeper(self, timeout: float | None = None) -> bool:
         """Stop the TTL sweeper thread if it's running.
 
         Args:
@@ -1396,7 +1391,7 @@ def _ensure_index_config(
 ) -> tuple[Any, SqliteIndexConfig]:
     """Process and validate index configuration."""
     index_config = index_config.copy()
-    tokenized: list[tuple[str, Union[Literal["$"], list[str]]]] = []
+    tokenized: list[tuple[str, Literal["$"] | list[str]]] = []
     tot = 0
     text_fields = index_config.get("text_fields") or ["$"]
     if isinstance(text_fields, str):

libs/checkpoint-sqlite/pyproject.toml

@@ -54,7 +54,7 @@ lint.select = [
   "B",  # flake8-bugbear
   "I",  # isort
 ]
-lint.ignore = ["E501", "B008", "UP007", "UP006"]
+lint.ignore = ["E501", "B008"]
 
 [tool.pytest-watcher]
 now = true

libs/checkpoint-sqlite/tests/checkpoint_utils.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
+from typing import Any, Protocol
 
 from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
 from langgraph.checkpoint.base.id import uuid6
 
 
 class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
+    def checkpoint(self) -> Any | None: ...
 
 
 def empty_checkpoint() -> Checkpoint:
@@ -23,10 +25,10 @@ def empty_checkpoint() -> Checkpoint:
 
 def create_checkpoint(
     checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
+    channels: Mapping[str, ChannelProtocol] | None,
     step: int,
     *,
-    id: Optional[str] = None,
+    id: str | None = None,
 ) -> Checkpoint:
     """Create a checkpoint for the given channels."""
     ts = datetime.now(timezone.utc).isoformat()

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -1,11 +1,11 @@
+from __future__ import annotations
+
 from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (  # noqa: UP035
     Any,
     Generic,
-    List,
     Literal,
     NamedTuple,
-    Optional,
     TypedDict,
     TypeVar,
     Union,
@@ -98,8 +98,8 @@ class CheckpointTuple(NamedTuple):
     config: RunnableConfig
     checkpoint: Checkpoint
     metadata: CheckpointMetadata
-    parent_config: Optional[RunnableConfig] = None
-    pending_writes: Optional[List[PendingWrite]] = None
+    parent_config: RunnableConfig | None = None
+    pending_writes: list[PendingWrite] | None = None
 
 
 class BaseCheckpointSaver(Generic[V]):
@@ -121,11 +121,11 @@ class BaseCheckpointSaver(Generic[V]):
     def __init__(
         self,
         *,
-        serde: Optional[SerializerProtocol] = None,
+        serde: SerializerProtocol | None = None,
     ) -> None:
         self.serde = maybe_add_typed_methods(serde or self.serde)
 
-    def get(self, config: RunnableConfig) -> Optional[Checkpoint]:
+    def get(self, config: RunnableConfig) -> Checkpoint | None:
         """Fetch a checkpoint using the given configuration.
 
         Args:
@@ -137,7 +137,7 @@ class BaseCheckpointSaver(Generic[V]):
         if value := self.get_tuple(config):
             return value.checkpoint
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Fetch a checkpoint tuple using the given configuration.
 
         Args:
@@ -153,11 +153,11 @@ class BaseCheckpointSaver(Generic[V]):
 
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints that match the given criteria.
 
@@ -229,7 +229,7 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
-    async def aget(self, config: RunnableConfig) -> Optional[Checkpoint]:
+    async def aget(self, config: RunnableConfig) -> Checkpoint | None:
         """Asynchronously fetch a checkpoint using the given configuration.
 
         Args:
@@ -241,7 +241,7 @@ class BaseCheckpointSaver(Generic[V]):
         if value := await self.aget_tuple(config):
             return value.checkpoint
 
-    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Asynchronously fetch a checkpoint tuple using the given configuration.
 
         Args:
@@ -257,11 +257,11 @@ class BaseCheckpointSaver(Generic[V]):
 
     async def alist(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[CheckpointTuple]:
         """Asynchronously list checkpoints that match the given criteria.
 
@@ -334,7 +334,7 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
-    def get_next_version(self, current: Optional[V]) -> V:
+    def get_next_version(self, current: V | None) -> V:
         """Generate the next version ID for a channel.
 
         Default is to use integer versions, incrementing by 1. If you override, you can use str/int/float versions,
@@ -361,7 +361,7 @@ class EmptyChannelError(Exception):
     pass
 
 
-def get_checkpoint_id(config: RunnableConfig) -> Optional[str]:
+def get_checkpoint_id(config: RunnableConfig) -> str | None:
     """Get checkpoint ID in a backwards-compatible manner (fallback on thread_ts)."""
     return config["configurable"].get(
         "checkpoint_id", config["configurable"].get("thread_ts")

libs/checkpoint/langgraph/checkpoint/base/id.py

@@ -3,10 +3,11 @@ https://github.com/oittaa/uuid6-python/blob/main/src/uuid6/__init__.py#L95
 Bundled in to avoid install issues with uuid6 package
 """
 
+from __future__ import annotations
+
 import random
 import time
 import uuid
-from typing import Optional
 
 _last_v6_timestamp = None
 
@@ -18,12 +19,12 @@ class UUID(uuid.UUID):
 
     def __init__(
         self,
-        hex: Optional[str] = None,
-        bytes: Optional[bytes] = None,
-        bytes_le: Optional[bytes] = None,
-        fields: Optional[tuple[int, int, int, int, int, int]] = None,
-        int: Optional[int] = None,
-        version: Optional[int] = None,
+        hex: str | None = None,
+        bytes: bytes | None = None,
+        bytes_le: bytes | None = None,
+        fields: tuple[int, int, int, int, int, int] | None = None,
+        int: int | None = None,
+        version: int | None = None,
         *,
         is_safe: uuid.SafeUUID = uuid.SafeUUID.unknown,
     ) -> None:
@@ -75,7 +76,7 @@ def _subsec_decode(value: int) -> int:
     return -(-value * 10**6 // 2**20)
 
 
-def uuid6(node: Optional[int] = None, clock_seq: Optional[int] = None) -> UUID:
+def uuid6(node: int | None = None, clock_seq: int | None = None) -> UUID:
     r"""UUID version 6 is a field-compatible version of UUIDv1, reordered for
     improved DB locality. It is expected that UUIDv6 will primarily be
     used in contexts where there are existing v1 UUIDs. Systems that do

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import os
 import pickle
@@ -7,7 +9,7 @@ from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import AbstractAsyncContextManager, AbstractContextManager, ExitStack
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 
@@ -63,9 +65,7 @@ class InMemorySaver(
     # thread ID ->  checkpoint NS -> checkpoint ID -> checkpoint mapping
     storage: defaultdict[
         str,
-        dict[
-            str, dict[str, tuple[tuple[str, bytes], tuple[str, bytes], Optional[str]]]
-        ],
+        dict[str, dict[str, tuple[tuple[str, bytes], tuple[str, bytes], str | None]]],
     ]
     # (thread ID, checkpoint NS, checkpoint ID) -> (task ID, write idx)
     writes: defaultdict[
@@ -74,7 +74,7 @@ class InMemorySaver(
     ]
     blobs: dict[
         tuple[
-            str, str, str, Union[str, int, float]
+            str, str, str, str | int | float
         ],  # thread id, checkpoint ns, channel, version
         tuple[str, bytes],
     ]
@@ -82,7 +82,7 @@ class InMemorySaver(
     def __init__(
         self,
         *,
-        serde: Optional[SerializerProtocol] = None,
+        serde: SerializerProtocol | None = None,
         factory: type[defaultdict] = defaultdict,
     ) -> None:
         super().__init__(serde=serde)
@@ -95,26 +95,26 @@ class InMemorySaver(
             self.stack.enter_context(self.writes)  # type: ignore[arg-type]
             self.stack.enter_context(self.blobs)  # type: ignore[arg-type]
 
-    def __enter__(self) -> "InMemorySaver":
+    def __enter__(self) -> InMemorySaver:
         return self.stack.__enter__()
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
         return self.stack.__exit__(exc_type, exc_value, traceback)
 
-    async def __aenter__(self) -> "InMemorySaver":
+    async def __aenter__(self) -> InMemorySaver:
         return self.stack.__enter__()
 
     async def __aexit__(
         self,
-        __exc_type: Optional[type[BaseException]],
-        __exc_value: Optional[BaseException],
-        __traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool | None:
         return self.stack.__exit__(__exc_type, __exc_value, __traceback)
 
     def _load_blobs(
@@ -129,7 +129,7 @@ class InMemorySaver(
                     channel_values[k] = self.serde.loads_typed(vv)
         return channel_values
 
-    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the in-memory storage.
 
         This method retrieves a checkpoint tuple from the in-memory storage based on the
@@ -213,11 +213,11 @@ class InMemorySaver(
 
     def list(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[CheckpointTuple]:
         """List checkpoints from the in-memory storage.
 
@@ -422,7 +422,7 @@ class InMemorySaver(
             if k[0] == thread_id:
                 del self.blobs[k]
 
-    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+    async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Asynchronous version of get_tuple.
 
         This method is an asynchronous wrapper around get_tuple that runs the synchronous
@@ -438,11 +438,11 @@ class InMemorySaver(
 
     async def alist(
         self,
-        config: Optional[RunnableConfig],
+        config: RunnableConfig | None,
         *,
-        filter: Optional[dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[CheckpointTuple]:
         """Asynchronous version of list.
 
@@ -512,7 +512,7 @@ class InMemorySaver(
         """
         return self.delete_thread(thread_id)
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: str | None) -> str:
         if current is None:
             current_v = 0
         elif isinstance(current, int):
@@ -571,7 +571,7 @@ class PersistentDict(defaultdict):
         self.sync()
         self.clear()
 
-    def __enter__(self) -> "PersistentDict":
+    def __enter__(self) -> PersistentDict:
         return self
 
     def __exit__(self, *exc_info: Any) -> None:

libs/checkpoint/langgraph/checkpoint/serde/jsonplus.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import decimal
 import importlib
@@ -5,6 +7,7 @@ import json
 import pathlib
 import pickle
 import re
+import sys
 from collections import deque
 from collections.abc import Sequence
 from datetime import date, datetime, time, timedelta, timezone
@@ -18,7 +21,7 @@ from ipaddress import (
     IPv6Interface,
     IPv6Network,
 )
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Callable, cast
 from uuid import UUID
 from zoneinfo import ZoneInfo
 
@@ -41,7 +44,7 @@ class JsonPlusSerializer(SerializerProtocol):
         self,
         *,
         pickle_fallback: bool = False,
-        __unpack_ext_hook__: Optional[Callable[[int, bytes], Any]] = None,
+        __unpack_ext_hook__: Callable[[int, bytes], Any] | None = None,
     ) -> None:
         self.pickle_fallback = pickle_fallback
         self._unpack_ext_hook = (
@@ -52,11 +55,11 @@ class JsonPlusSerializer(SerializerProtocol):
 
     def _encode_constructor_args(
         self,
-        constructor: Union[Callable, type[Any]],
+        constructor: Callable | type[Any],
         *,
-        method: Union[None, str, Sequence[Union[None, str]]] = None,
-        args: Optional[Sequence[Any]] = None,
-        kwargs: Optional[dict[str, Any]] = None,
+        method: None | str | Sequence[None | str] = None,
+        args: Sequence[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         out = {
             "lc": 2,
@@ -71,7 +74,7 @@ class JsonPlusSerializer(SerializerProtocol):
             out["kwargs"] = kwargs
         return out
 
-    def _default(self, obj: Any) -> Union[str, dict[str, Any]]:
+    def _default(self, obj: Any) -> str | dict[str, Any]:
         if isinstance(obj, Serializable):
             return cast(dict[str, Any], obj.to_json())
         elif hasattr(obj, "model_dump") and callable(obj.model_dump):
@@ -249,9 +252,10 @@ EXT_CONSTRUCTOR_KW_ARGS = 2
 EXT_METHOD_SINGLE_ARG = 3
 EXT_PYDANTIC_V1 = 4
 EXT_PYDANTIC_V2 = 5
+EXT_NUMPY_ARRAY = 6
 
 
-def _msgpack_default(obj: Any) -> Union[str, ormsgpack.Ext]:
+def _msgpack_default(obj: Any) -> str | ormsgpack.Ext:
     if hasattr(obj, "model_dump") and callable(obj.model_dump):  # pydantic v2
         return ormsgpack.Ext(
             EXT_PYDANTIC_V2,
@@ -318,13 +322,6 @@ def _msgpack_default(obj: Any) -> Union[str, ormsgpack.Ext]:
                 (obj.__class__.__module__, obj.__class__.__name__, obj.hex),
             ),
         )
-    elif isinstance(obj, bytearray):
-        return ormsgpack.Ext(
-            EXT_CONSTRUCTOR_SINGLE_ARG,
-            _msgpack_enc(
-                (obj.__class__.__module__, obj.__class__.__name__, bytes(obj)),
-            ),
-        )
     elif isinstance(obj, decimal.Decimal):
         return ormsgpack.Ext(
             EXT_CONSTRUCTOR_SINGLE_ARG,
@@ -463,6 +460,22 @@ def _msgpack_default(obj: Any) -> Union[str, ormsgpack.Ext]:
                 ),
             ),
         )
+    elif (np_mod := sys.modules.get("numpy")) is not None and isinstance(
+        obj, np_mod.ndarray
+    ):
+        order = "F" if obj.flags.f_contiguous and not obj.flags.c_contiguous else "C"
+        if obj.flags.c_contiguous:
+            mv = memoryview(obj)
+            try:
+                meta = (obj.dtype.str, obj.shape, order, mv)
+                return ormsgpack.Ext(EXT_NUMPY_ARRAY, _msgpack_enc(meta))
+            finally:
+                mv.release()
+        else:
+            buf = obj.tobytes(order="A")
+            meta = (obj.dtype.str, obj.shape, order, buf)
+            return ormsgpack.Ext(EXT_NUMPY_ARRAY, _msgpack_enc(meta))
+
     elif isinstance(obj, BaseException):
         return repr(obj)
     else:
@@ -544,6 +557,17 @@ def _msgpack_ext_hook(code: int, data: bytes) -> Any:
                 return tup[2]
             except NameError:
                 return
+    elif code == EXT_NUMPY_ARRAY:
+        try:
+            import numpy as _np
+
+            dtype_str, shape, order, buf = ormsgpack.unpackb(
+                data, ext_hook=_msgpack_ext_hook, option=ormsgpack.OPT_NON_STR_KEYS
+            )
+            arr = _np.frombuffer(buf, dtype=_np.dtype(dtype_str))
+            return arr.reshape(shape, order=order)
+        except Exception:
+            return
 
 
 def _msgpack_ext_hook_to_json(code: int, data: bytes) -> Any:
@@ -624,6 +648,19 @@ def _msgpack_ext_hook_to_json(code: int, data: bytes) -> Any:
             return tup[2]
         except Exception:
             return
+    elif code == EXT_NUMPY_ARRAY:
+        try:
+            import numpy as _np
+
+            dtype_str, shape, order, buf = ormsgpack.unpackb(
+                data,
+                ext_hook=_msgpack_ext_hook_to_json,
+                option=ormsgpack.OPT_NON_STR_KEYS,
+            )
+            arr = _np.frombuffer(buf, dtype=_np.dtype(dtype_str))
+            return arr.reshape(shape, order=order).tolist()
+        except Exception:
+            return
 
 
 _option = (

libs/checkpoint/langgraph/store/base/__init__.py

@@ -9,6 +9,8 @@ Core types:
     - Op: Get/Put/Search/List operations
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
 from datetime import datetime
@@ -16,7 +18,6 @@ from typing import (
     Any,
     Literal,
     NamedTuple,
-    Optional,
     TypedDict,
     Union,
     cast,
@@ -127,7 +128,7 @@ class SearchItem(Item):
         value: dict[str, Any],
         created_at: datetime,
         updated_at: datetime,
-        score: Optional[float] = None,
+        score: float | None = None,
     ) -> None:
         """Initialize a result item.
 
@@ -242,7 +243,7 @@ class SearchOp(NamedTuple):
         ```
     """
 
-    filter: Optional[dict[str, Any]] = None
+    filter: dict[str, Any] | None = None
     """Key-value pairs for filtering results based on exact matches or comparison operators.
 
     The filter supports both exact matches and operator-based comparisons.
@@ -284,7 +285,7 @@ class SearchOp(NamedTuple):
     offset: int = 0
     """Number of matching items to skip for pagination."""
 
-    query: Optional[str] = None
+    query: str | None = None
     """Natural language search query for semantic search capabilities.
 
     ???+ example "Examples"
@@ -379,7 +380,7 @@ class ListNamespacesOp(NamedTuple):
 
     """
 
-    match_conditions: Optional[tuple[MatchCondition, ...]] = None
+    match_conditions: tuple[MatchCondition, ...] | None = None
     """Optional conditions for filtering namespaces.
 
     ???+ example "Examples"
@@ -397,7 +398,7 @@ class ListNamespacesOp(NamedTuple):
         ```
     """
 
-    max_depth: Optional[int] = None
+    max_depth: int | None = None
     """Maximum depth of namespace hierarchy to return.
 
     Note:
@@ -452,7 +453,7 @@ class PutOp(NamedTuple):
         the full path would effectively be "documents/user123/report1"
     """
 
-    value: Optional[dict[str, Any]]
+    value: dict[str, Any] | None
     """The data to store, or None to mark the item for deletion.
 
     The value must be a dictionary with string keys and JSON-serializable values.
@@ -466,7 +467,7 @@ class PutOp(NamedTuple):
         }
     """
 
-    index: Optional[Union[Literal[False], list[str]]] = None  # type: ignore[assignment]
+    index: Literal[False] | list[str] | None = None  # type: ignore[assignment]
     """Controls how the item's fields are indexed for search operations.
 
     Indexing configuration determines how the item can be found through search:
@@ -501,7 +502,7 @@ class PutOp(NamedTuple):
         ]
         ```
     """
-    ttl: Optional[float] = None
+    ttl: float | None = None
     """Controls the TTL (time-to-live) for the item in minutes.
 
     If provided, and if the store you are using supports this feature, the item
@@ -530,14 +531,14 @@ class TTLConfig(TypedDict, total=False):
     This can be overridden per-operation by explicitly setting refresh_ttl.
     Defaults to True if not configured.
     """
-    default_ttl: Optional[float]
+    default_ttl: float | None
     """Default TTL (time-to-live) in minutes for new items.
     
     If provided, new items will expire after this many minutes after their last access.
     The expiration timer refreshes on both read and write operations.
     Defaults to None (no expiration).
     """
-    sweep_interval_minutes: Optional[int]
+    sweep_interval_minutes: int | None
     """Interval in minutes between TTL sweep operations.
     
     If provided, the store will periodically delete expired items based on TTL.
@@ -565,7 +566,7 @@ class IndexConfig(TypedDict, total=False):
         - cohere:embed-multilingual-light-v3.0: 384
     """
 
-    embed: Union[Embeddings, EmbeddingsFunc, AEmbeddingsFunc, str]
+    embed: Embeddings | EmbeddingsFunc | AEmbeddingsFunc | str
     """Optional function to generate embeddings from text.
     
     Can be specified in three ways:
@@ -633,7 +634,7 @@ class IndexConfig(TypedDict, total=False):
         ```
     """
 
-    fields: Optional[list[str]]
+    fields: list[str] | None
     """Fields to extract text from for embedding generation.
     
     Controls which parts of stored items are embedded for semantic search. Follows JSON path syntax:
@@ -690,7 +691,7 @@ class BaseStore(ABC):
     """
 
     supports_ttl: bool = False
-    ttl_config: Optional[TTLConfig] = None
+    ttl_config: TTLConfig | None = None
 
     __slots__ = ("__weakref__",)
 
@@ -723,8 +724,8 @@ class BaseStore(ABC):
         namespace: tuple[str, ...],
         key: str,
         *,
-        refresh_ttl: Optional[bool] = None,
-    ) -> Optional[Item]:
+        refresh_ttl: bool | None = None,
+    ) -> Item | None:
         """Retrieve a single item.
 
         Args:
@@ -746,11 +747,11 @@ class BaseStore(ABC):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
-        filter: Optional[dict[str, Any]] = None,
+        query: str | None = None,
+        filter: dict[str, Any] | None = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool | None = None,
     ) -> list[SearchItem]:
         """Search for items within a namespace prefix.
 
@@ -817,9 +818,9 @@ class BaseStore(ABC):
         namespace: tuple[str, ...],
         key: str,
         value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
+        index: Literal[False] | list[str] | None = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: float | None | NotProvided = NOT_PROVIDED,
     ) -> None:
         """Store or update an item in the store.
 
@@ -901,9 +902,9 @@ class BaseStore(ABC):
     def list_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
+        prefix: NamespacePath | None = None,
+        suffix: NamespacePath | None = None,
+        max_depth: int | None = None,
         limit: int = 100,
         offset: int = 0,
     ) -> list[tuple[str, ...]]:
@@ -956,8 +957,8 @@ class BaseStore(ABC):
         namespace: tuple[str, ...],
         key: str,
         *,
-        refresh_ttl: Optional[bool] = None,
-    ) -> Optional[Item]:
+        refresh_ttl: bool | None = None,
+    ) -> Item | None:
         """Asynchronously retrieve a single item.
 
         Args:
@@ -984,11 +985,11 @@ class BaseStore(ABC):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
-        filter: Optional[dict[str, Any]] = None,
+        query: str | None = None,
+        filter: dict[str, Any] | None = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool | None = None,
     ) -> list[SearchItem]:
         """Asynchronously search for items within a namespace prefix.
 
@@ -1058,9 +1059,9 @@ class BaseStore(ABC):
         namespace: tuple[str, ...],
         key: str,
         value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
+        index: Literal[False] | list[str] | None = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: float | None | NotProvided = NOT_PROVIDED,
     ) -> None:
         """Asynchronously store or update an item in the store.
 
@@ -1150,9 +1151,9 @@ class BaseStore(ABC):
     async def alist_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
+        prefix: NamespacePath | None = None,
+        suffix: NamespacePath | None = None,
+        max_depth: int | None = None,
         limit: int = 100,
         offset: int = 0,
     ) -> list[tuple[str, ...]]:
@@ -1226,7 +1227,7 @@ def _validate_namespace(namespace: tuple[str, ...]) -> None:
 
 
 def _ensure_refresh(
-    ttl_config: Optional[TTLConfig], refresh_ttl: Optional[bool] = None
+    ttl_config: TTLConfig | None, refresh_ttl: bool | None = None
 ) -> bool:
     if refresh_ttl is not None:
         return refresh_ttl
@@ -1236,9 +1237,9 @@ def _ensure_refresh(
 
 
 def _ensure_ttl(
-    ttl_config: Optional[TTLConfig],
-    ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
-) -> Optional[float]:
+    ttl_config: TTLConfig | None,
+    ttl: float | None | NotProvided = NOT_PROVIDED,
+) -> float | None:
     if ttl is NOT_PROVIDED:
         if ttl_config:
             return ttl_config.get("default_ttl")

libs/checkpoint/langgraph/store/base/batch.py

@@ -1,10 +1,12 @@
 """Utilities for batching operations in a background task."""
 
+from __future__ import annotations
+
 import asyncio
 import functools
 import weakref
 from collections.abc import Iterable
-from typing import Any, Callable, Literal, Optional, TypeVar, Union
+from typing import Any, Callable, Literal, TypeVar
 
 from langgraph.store.base import (
     NOT_PROVIDED,
@@ -30,7 +32,7 @@ F = TypeVar("F", bound=Callable)
 
 def _check_loop(func: F) -> F:
     @functools.wraps(func)
-    def wrapper(store: "AsyncBatchedBaseStore", *args: Any, **kwargs: Any) -> Any:
+    def wrapper(store: AsyncBatchedBaseStore, *args: Any, **kwargs: Any) -> Any:
         method_name: str = func.__name__
         try:
             current_loop = asyncio.get_running_loop()
@@ -75,8 +77,8 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
         *,
-        refresh_ttl: Optional[bool] = None,
-    ) -> Optional[Item]:
+        refresh_ttl: bool | None = None,
+    ) -> Item | None:
         assert not self._task.done()
         fut = self._loop.create_future()
         self._aqueue.put_nowait(
@@ -96,11 +98,11 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
-        filter: Optional[dict[str, Any]] = None,
+        query: str | None = None,
+        filter: dict[str, Any] | None = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool | None = None,
     ) -> list[SearchItem]:
         assert not self._task.done()
         fut = self._loop.create_future()
@@ -124,9 +126,9 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
         value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
+        index: Literal[False] | list[str] | None = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: float | None | NotProvided = NOT_PROVIDED,
     ) -> None:
         assert not self._task.done()
         _validate_namespace(namespace)
@@ -154,9 +156,9 @@ class AsyncBatchedBaseStore(BaseStore):
     async def alist_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
+        prefix: NamespacePath | None = None,
+        suffix: NamespacePath | None = None,
+        max_depth: int | None = None,
         limit: int = 100,
         offset: int = 0,
     ) -> list[tuple[str, ...]]:
@@ -187,8 +189,8 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
         *,
-        refresh_ttl: Optional[bool] = None,
-    ) -> Optional[Item]:
+        refresh_ttl: bool | None = None,
+    ) -> Item | None:
         return asyncio.run_coroutine_threadsafe(
             self.aget(namespace, key=key, refresh_ttl=refresh_ttl), self._loop
         ).result()
@@ -199,11 +201,11 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
-        filter: Optional[dict[str, Any]] = None,
+        query: str | None = None,
+        filter: dict[str, Any] | None = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool | None = None,
     ) -> list[SearchItem]:
         return asyncio.run_coroutine_threadsafe(
             self.asearch(
@@ -223,9 +225,9 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
         value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
+        index: Literal[False] | list[str] | None = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: float | None | NotProvided = NOT_PROVIDED,
     ) -> None:
         _validate_namespace(namespace)
         asyncio.run_coroutine_threadsafe(
@@ -253,9 +255,9 @@ class AsyncBatchedBaseStore(BaseStore):
     def list_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
+        prefix: NamespacePath | None = None,
+        suffix: NamespacePath | None = None,
+        max_depth: int | None = None,
         limit: int = 100,
         offset: int = 0,
     ) -> list[tuple[str, ...]]:
@@ -271,7 +273,7 @@ class AsyncBatchedBaseStore(BaseStore):
         ).result()
 
 
-def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
+def _dedupe_ops(values: list[Op]) -> tuple[list[int] | None, list[Op]]:
     """Dedupe operations while preserving order for results.
 
     Args:

libs/checkpoint/langgraph/store/base/embed.py

@@ -6,11 +6,13 @@ with LangChain-compatible tools while maintaining support for both synchronous a
 asynchronous operations.
 """
 
+from __future__ import annotations
+
 import asyncio
 import functools
 import json
 from collections.abc import Awaitable, Sequence
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable
 
 from langchain_core.embeddings import Embeddings
 
@@ -30,7 +32,7 @@ Similar to EmbeddingsFunc, but returns an awaitable that resolves to the embeddi
 
 
 def ensure_embeddings(
-    embed: Union[Embeddings, EmbeddingsFunc, AEmbeddingsFunc, str, None],
+    embed: Embeddings | EmbeddingsFunc | AEmbeddingsFunc | str | None,
 ) -> Embeddings:
     """Ensure that an embedding function conforms to LangChain's Embeddings interface.
 
@@ -141,7 +143,7 @@ class EmbeddingsLambda(Embeddings):
 
     def __init__(
         self,
-        func: Union[EmbeddingsFunc, AEmbeddingsFunc],
+        func: EmbeddingsFunc | AEmbeddingsFunc,
     ) -> None:
         if func is None:
             raise ValueError("func must be provided")
@@ -221,7 +223,7 @@ class EmbeddingsLambda(Embeddings):
         return (await afunc([text]))[0]
 
 
-def get_text_at_path(obj: Any, path: Union[str, list[str]]) -> list[str]:
+def get_text_at_path(obj: Any, path: str | list[str]) -> list[str]:
     """Extract text from an object using a path expression or pre-tokenized path.
 
     Args:
@@ -279,7 +281,7 @@ def get_text_at_path(obj: Any, path: Union[str, list[str]]) -> list[str]:
             for field in fields:
                 nested_tokens = tokenize_path(field)
                 if nested_tokens:
-                    current_obj: Optional[dict] = obj
+                    current_obj: dict | None = obj
                     for nested_token in nested_tokens:
                         if (
                             isinstance(current_obj, dict)
@@ -404,7 +406,7 @@ def _is_async_callable(
 
 
 @functools.lru_cache
-def _get_init_embeddings() -> Optional[Callable[[str], Embeddings]]:
+def _get_init_embeddings() -> Callable[[str], Embeddings] | None:
     try:
         from langchain.embeddings import init_embeddings  # type: ignore
 

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

@@ -99,6 +99,8 @@ Tip:
     ```
 """
 
+from __future__ import annotations
+
 import asyncio
 import concurrent.futures as cf
 import functools
@@ -107,7 +109,7 @@ from collections import defaultdict
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from importlib import util
-from typing import Any, Optional
+from typing import Any
 
 from langchain_core.embeddings import Embeddings
 
@@ -178,7 +180,7 @@ class InMemoryStore(BaseStore):
         "embeddings",
     )
 
-    def __init__(self, *, index: Optional[IndexConfig] = None) -> None:
+    def __init__(self, *, index: IndexConfig | None = None) -> None:
         # Both _data and _vectors are wrapped in the In-memory API
         # Do not change their names
         self._data: dict[tuple[str, ...], dict[str, Item]] = defaultdict(dict)
@@ -189,7 +191,7 @@ class InMemoryStore(BaseStore):
         self.index_config = index
         if self.index_config:
             self.index_config = self.index_config.copy()
-            self.embeddings: Optional[Embeddings] = ensure_embeddings(
+            self.embeddings: Embeddings | None = ensure_embeddings(
                 self.index_config.get("embed"),
             )
             self.index_config["__tokenized_fields"] = [
@@ -325,7 +327,7 @@ class InMemoryStore(BaseStore):
                 )
                 # max pooling
                 seen: set[tuple[tuple[str, ...], str]] = set()
-                kept: list[tuple[Optional[float], Item]] = []
+                kept: list[tuple[float | None, Item]] = []
                 for score, item in sorted_results:
                     key = (item.namespace, item.key)
                     if key in seen:
@@ -494,7 +496,7 @@ def _cosine_similarity(X: list[float], Y: list[list[float]]) -> list[float]:
     if not Y:
         return []
     if _check_numpy():
-        import numpy as np  # type: ignore[import-not-found]
+        import numpy as np
 
         X_arr = np.array(X) if not isinstance(X, np.ndarray) else X
         Y_arr = np.array(Y) if not isinstance(Y, np.ndarray) else Y

libs/checkpoint/pyproject.toml

@@ -13,7 +13,7 @@ license = "MIT"
 license-files = ['LICENSE']
 dependencies = [
     "langchain-core>=0.2.38",
-    "ormsgpack>=1.8.0",
+    "ormsgpack>=1.10.0",
 ]
 
 [project.urls]
@@ -29,6 +29,8 @@ dev = [
   "pytest-watcher",
   "mypy",
   "dataclasses-json",
+  "numpy",
+  "pandas",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -46,7 +48,7 @@ lint.select = [
   "B",  # flake8-bugbear
   "I",  # isort
 ]
-lint.ignore = ["E501", "B008", "UP007", "UP006"]
+lint.ignore = ["E501", "B008"]
 
 [tool.pytest-watcher]
 now = true

libs/checkpoint/tests/checkpoint_utils.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
+from typing import Any, Protocol
 
 from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
 from langgraph.checkpoint.base.id import uuid6
 
 
 class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
+    def checkpoint(self) -> Any | None: ...
 
 
 def empty_checkpoint() -> Checkpoint:
@@ -23,10 +25,10 @@ def empty_checkpoint() -> Checkpoint:
 
 def create_checkpoint(
     checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
+    channels: Mapping[str, ChannelProtocol] | None,
     step: int,
     *,
-    id: Optional[str] = None,
+    id: str | None = None,
 ) -> Checkpoint:
     """Create a checkpoint for the given channels."""
     ts = datetime.now(timezone.utc).isoformat()

libs/checkpoint/tests/test_jsonplus.py

@@ -11,6 +11,9 @@ from ipaddress import IPv4Address
 from zoneinfo import ZoneInfo
 
 import dataclasses_json
+import numpy as np
+import pandas as pd
+import pytest
 from pydantic import BaseModel, SecretStr
 from pydantic.v1 import BaseModel as BaseModelV1
 from pydantic.v1 import SecretStr as SecretStrV1
@@ -295,19 +298,174 @@ def test_serde_jsonplus_bytearray() -> None:
     assert serde.loads_typed(dumped) == some_bytearray
 
 
-def test_loads_cannot_find() -> None:
+@pytest.mark.parametrize(
+    "arr",
+    [
+        np.arange(9, dtype=np.int32).reshape(3, 3),
+        np.asfortranarray(np.arange(9, dtype=np.float64).reshape(3, 3)),
+        np.arange(12, dtype=np.int16)[::2].reshape(3, 2),
+    ],
+)
+def test_serde_jsonplus_numpy_array(arr: np.ndarray) -> None:
     serde = JsonPlusSerializer()
 
-    dumped = (
-        "json",
-        b'{"lc": 2, "type": "constructor", "id": ["tests", "test_jsonplus", "MyPydanticccc"], "method": null, "args": [], "kwargs": {"foo": "foo", "bar": 1}}',
-    )
+    dumped = serde.dumps_typed(arr)
+    assert dumped[0] == "msgpack"
+    result = serde.loads_typed(dumped)
+    assert isinstance(result, np.ndarray)
+    assert result.dtype == arr.dtype
+    assert np.array_equal(result, arr)
 
-    assert serde.loads_typed(dumped) is None, "Should return None if cannot find class"
 
-    dumped = (
-        "json",
-        b'{"lc": 2, "type": "constructor", "id": ["tests", "test_jsonpluss", "MyPydantic"], "method": null, "args": [], "kwargs": {"foo": "foo", "bar": 1}}',
-    )
+@pytest.mark.parametrize(
+    "arr",
+    [
+        np.arange(6, dtype=np.float32).reshape(2, 3),
+        np.asfortranarray(np.arange(4, dtype=np.complex128).reshape(2, 2)),
+    ],
+)
+def test_serde_jsonplus_numpy_array_json_hook(arr: np.ndarray) -> None:
+    serde = JsonPlusSerializer(__unpack_ext_hook__=_msgpack_ext_hook_to_json)
+    dumped = serde.dumps_typed(arr)
+    assert dumped[0] == "msgpack"
+    result = serde.loads_typed(dumped)
+    assert isinstance(result, list)
+    assert result == arr.tolist()
 
-    assert serde.loads_typed(dumped) is None, "Should return None if cannot find module"
+
+@pytest.mark.parametrize(
+    "df",
+    [
+        pd.DataFrame(),
+        pd.DataFrame({"int_col": [1, 2, 3]}),
+        pd.DataFrame({"float_col": [1.1, 2.2, 3.3]}),
+        pd.DataFrame({"str_col": ["a", "b", "c"]}),
+        pd.DataFrame({"bool_col": [True, False, True]}),
+        pd.DataFrame(
+            {
+                "datetime_col": [
+                    datetime(2024, 1, 1),
+                    datetime(2024, 1, 2),
+                    datetime(2024, 1, 3),
+                ]
+            }
+        ),
+        pd.DataFrame(
+            {
+                "int_col": [1, 2, 3],
+                "float_col": [1.1, 2.2, 3.3],
+                "str_col": ["a", "b", "c"],
+            }
+        ),
+        pd.DataFrame(
+            {
+                "int_col": [1, 2, None],
+                "float_col": [1.1, None, 3.3],
+                "str_col": ["a", None, "c"],
+            }
+        ),
+        pd.DataFrame({"cat_col": pd.Categorical(["a", "b", "a", "c"])}),
+        pd.DataFrame(
+            {
+                "int8": pd.array([1, 2, 3], dtype="int8"),
+                "int16": pd.array([10, 20, 30], dtype="int16"),
+                "int32": pd.array([100, 200, 300], dtype="int32"),
+                "int64": pd.array([1000, 2000, 3000], dtype="int64"),
+                "float32": pd.array([1.1, 2.2, 3.3], dtype="float32"),
+                "float64": pd.array([10.1, 20.2, 30.3], dtype="float64"),
+            }
+        ),
+        pd.DataFrame({"value": [1, 2, 3]}, index=["x", "y", "z"]),
+        pd.DataFrame(
+            [[1, 2, 3, 4]],
+            columns=pd.MultiIndex.from_tuples(
+                [("A", "X"), ("A", "Y"), ("B", "X"), ("B", "Y")]
+            ),
+        ),
+        pd.DataFrame(
+            {"value": [1, 2, 3]}, index=pd.date_range("2024-01-01", periods=3, freq="D")
+        ),
+        pd.DataFrame(
+            {
+                "col1": range(1000),
+                "col2": [f"str_{i}" for i in range(1000)],
+                "col3": np.random.rand(1000),
+            }
+        ),
+        pd.DataFrame(
+            {"tz_datetime": pd.date_range("2024-01-01", periods=3, freq="D", tz="UTC")}
+        ),
+        pd.DataFrame({"timedelta": pd.to_timedelta([1, 2, 3], unit="D")}),
+        pd.DataFrame({"period": pd.period_range("2024-01", periods=3, freq="M")}),
+        pd.DataFrame({"interval": pd.interval_range(start=0, end=3, periods=3)}),
+        pd.DataFrame({"unicode": ["Hello 🌍", "Python 🐍", "Data 📊"]}),
+        pd.DataFrame({"mixed": [1, "string", [1, 2, 3], {"key": "value"}]}),
+        pd.DataFrame({"a": [1], "b": ["test"], "c": [3.14]}),
+        pd.DataFrame({"single": [42]}),
+        pd.DataFrame(
+            {
+                "small": [sys.float_info.min, 0, sys.float_info.max],
+                "large_int": [-(2**63), 0, 2**63 - 1],
+            }
+        ),
+        pd.DataFrame({"special_strings": ["", "null", "None", "NaN", "inf", "-inf"]}),
+        pd.DataFrame({"bytes_col": [b"hello", b"world", b"\x00\x01\x02"]}),
+    ],
+)
+def test_serde_jsonplus_pandas_dataframe(df: pd.DataFrame) -> None:
+    serde = JsonPlusSerializer(pickle_fallback=True)
+
+    dumped = serde.dumps_typed(df)
+    assert dumped[0] == "pickle"
+    result = serde.loads_typed(dumped)
+    assert result.equals(df)
+
+
+@pytest.mark.parametrize(
+    "series",
+    [
+        pd.Series([]),
+        pd.Series([1, 2, 3]),
+        pd.Series([1.1, 2.2, 3.3]),
+        pd.Series(["a", "b", "c"]),
+        pd.Series([True, False, True]),
+        pd.Series([datetime(2024, 1, 1), datetime(2024, 1, 2), datetime(2024, 1, 3)]),
+        pd.Series([1, 2, None]),
+        pd.Series([1.1, None, 3.3]),
+        pd.Series(["a", None, "c"]),
+        pd.Series(pd.Categorical(["a", "b", "a", "c"])),
+        pd.Series([1, 2, 3], dtype="int8"),
+        pd.Series([10, 20, 30], dtype="int16"),
+        pd.Series([100, 200, 300], dtype="int32"),
+        pd.Series([1000, 2000, 3000], dtype="int64"),
+        pd.Series([1.1, 2.2, 3.3], dtype="float32"),
+        pd.Series([10.1, 20.2, 30.3], dtype="float64"),
+        pd.Series([1, 2, 3], index=["x", "y", "z"]),
+        pd.Series([1, 2, 3], index=pd.date_range("2024-01-01", periods=3, freq="D")),
+        pd.Series(range(1000)),
+        pd.Series(pd.date_range("2024-01-01", periods=3, freq="D", tz="UTC")),
+        pd.Series(pd.to_timedelta([1, 2, 3], unit="D")),
+        pd.Series(pd.period_range("2024-01", periods=3, freq="M")),
+        pd.Series(pd.interval_range(start=0, end=3, periods=3)),
+        pd.Series(["Hello 🌍", "Python 🐍", "Data 📊"]),
+        pd.Series([1, "string", [1, 2, 3], {"key": "value"}]),
+        pd.Series([42], name="single"),
+        pd.Series([sys.float_info.min, 0, sys.float_info.max]),
+        pd.Series([-(2**63), 0, 2**63 - 1]),
+        pd.Series(["", "null", "None", "NaN", "inf", "-inf"]),
+        pd.Series([b"hello", b"world", b"\x00\x01\x02"]),
+        pd.Series([1, 2, 3], name="named_series"),
+        pd.Series(
+            [10, 20],
+            index=pd.MultiIndex.from_tuples([("a", 1), ("b", 2)], names=["x", "y"]),
+        ),
+    ],
+)
+def test_serde_jsonplus_pandas_series(series: pd.Series) -> None:
+    serde = JsonPlusSerializer(pickle_fallback=True)
+    dumped = serde.dumps_typed(series)
+
+    assert dumped[0] == "pickle"
+    result = serde.loads_typed(dumped)
+
+    assert result.equals(series)

libs/checkpoint/uv.lock

@@ -3,7 +3,10 @@ revision = 1
 requires-python = ">=3.9"
 resolution-markers = [
     "python_full_version >= '3.12.4'",
-    "python_full_version < '3.12.4'",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4'",
+    "python_full_version == '3.11.*'",
+    "python_full_version == '3.10.*'",
+    "python_full_version < '3.10'",
 ]
 
 [[package]]
@@ -218,7 +221,7 @@ name = "exceptiongroup"
 version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.12.4'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749 }
 wheels = [
@@ -333,6 +336,10 @@ dev = [
     { name = "codespell" },
     { name = "dataclasses-json" },
     { name = "mypy" },
+    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" },
+    { name = "numpy", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "pandas" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
@@ -343,7 +350,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "langchain-core", specifier = ">=0.2.38" },
-    { name = "ormsgpack", specifier = ">=1.8.0" },
+    { name = "ormsgpack", specifier = ">=1.10.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -351,6 +358,8 @@ dev = [
     { name = "codespell" },
     { name = "dataclasses-json" },
     { name = "mypy" },
+    { name = "numpy" },
+    { name = "pandas" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
@@ -441,6 +450,189 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 },
 ]
 
+[[package]]
+name = "numpy"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.10'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 },
+    { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 },
+    { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 },
+    { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 },
+    { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 },
+    { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 },
+    { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 },
+    { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 },
+    { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 },
+    { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 },
+    { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 },
+    { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 },
+    { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 },
+    { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 },
+    { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 },
+    { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 },
+    { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 },
+    { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 },
+    { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 },
+    { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 },
+    { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 },
+    { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 },
+    { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 },
+    { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 },
+    { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 },
+    { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 },
+    { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 },
+    { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 },
+    { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 },
+    { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 },
+    { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 },
+    { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 },
+    { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 },
+    { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 },
+    { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 },
+    { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 },
+    { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 },
+    { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 },
+    { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 },
+    { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 },
+    { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 },
+    { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 },
+    { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.10.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245 },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048 },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542 },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301 },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320 },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050 },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034 },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185 },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149 },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620 },
+    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963 },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743 },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616 },
+    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579 },
+    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005 },
+    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570 },
+    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548 },
+    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521 },
+    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866 },
+    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455 },
+    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348 },
+    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362 },
+    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103 },
+    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382 },
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462 },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618 },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511 },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783 },
+    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506 },
+    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190 },
+    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828 },
+    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006 },
+    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765 },
+    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736 },
+    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719 },
+    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072 },
+    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213 },
+    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632 },
+    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532 },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885 },
+    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467 },
+    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144 },
+    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217 },
+    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014 },
+    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935 },
+    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122 },
+    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143 },
+    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260 },
+    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225 },
+    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374 },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391 },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754 },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476 },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666 },
+]
+
+[[package]]
+name = "numpy"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12.4'",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4'",
+    "python_full_version == '3.11.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/db/8e12381333aea300890829a0a36bfa738cac95475d88982d538725143fd9/numpy-2.3.0.tar.gz", hash = "sha256:581f87f9e9e9db2cba2141400e160e9dd644ee248788d6f90636eeb8fd9260a6", size = 20382813 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/5f/df67435257d827eb3b8af66f585223dc2c3f2eb7ad0b50cb1dae2f35f494/numpy-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c3c9fdde0fa18afa1099d6257eb82890ea4f3102847e692193b54e00312a9ae9", size = 21199688 },
+    { url = "https://files.pythonhosted.org/packages/e5/ce/aad219575055d6c9ef29c8c540c81e1c38815d3be1fe09cdbe53d48ee838/numpy-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46d16f72c2192da7b83984aa5455baee640e33a9f1e61e656f29adf55e406c2b", size = 14359277 },
+    { url = "https://files.pythonhosted.org/packages/29/6b/2d31da8e6d2ec99bed54c185337a87f8fbeccc1cd9804e38217e92f3f5e2/numpy-2.3.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a0be278be9307c4ab06b788f2a077f05e180aea817b3e41cebbd5aaf7bd85ed3", size = 5376069 },
+    { url = "https://files.pythonhosted.org/packages/7d/2a/6c59a062397553ec7045c53d5fcdad44e4536e54972faa2ba44153bca984/numpy-2.3.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:99224862d1412d2562248d4710126355d3a8db7672170a39d6909ac47687a8a4", size = 6913057 },
+    { url = "https://files.pythonhosted.org/packages/d5/5a/8df16f258d28d033e4f359e29d3aeb54663243ac7b71504e89deeb813202/numpy-2.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2393a914db64b0ead0ab80c962e42d09d5f385802006a6c87835acb1f58adb96", size = 14568083 },
+    { url = "https://files.pythonhosted.org/packages/0a/92/0528a563dfc2cdccdcb208c0e241a4bb500d7cde218651ffb834e8febc50/numpy-2.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:7729c8008d55e80784bd113787ce876ca117185c579c0d626f59b87d433ea779", size = 16929402 },
+    { url = "https://files.pythonhosted.org/packages/e4/2f/e7a8c8d4a2212c527568d84f31587012cf5497a7271ea1f23332142f634e/numpy-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:06d4fb37a8d383b769281714897420c5cc3545c79dc427df57fc9b852ee0bf58", size = 15879193 },
+    { url = "https://files.pythonhosted.org/packages/e2/c3/dada3f005953847fe35f42ac0fe746f6e1ea90b4c6775e4be605dcd7b578/numpy-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c39ec392b5db5088259c68250e342612db82dc80ce044cf16496cf14cf6bc6f8", size = 18665318 },
+    { url = "https://files.pythonhosted.org/packages/3b/ae/3f448517dedefc8dd64d803f9d51a8904a48df730e00a3c5fb1e75a60620/numpy-2.3.0-cp311-cp311-win32.whl", hash = "sha256:ee9d3ee70d62827bc91f3ea5eee33153212c41f639918550ac0475e3588da59f", size = 6601108 },
+    { url = "https://files.pythonhosted.org/packages/8c/4a/556406d2bb2b9874c8cbc840c962683ac28f21efbc9b01177d78f0199ca1/numpy-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:43c55b6a860b0eb44d42341438b03513cf3879cb3617afb749ad49307e164edd", size = 13021525 },
+    { url = "https://files.pythonhosted.org/packages/ed/ee/bf54278aef30335ffa9a189f869ea09e1a195b3f4b93062164a3b02678a7/numpy-2.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:2e6a1409eee0cb0316cb64640a49a49ca44deb1a537e6b1121dc7c458a1299a8", size = 10170327 },
+    { url = "https://files.pythonhosted.org/packages/89/59/9df493df81ac6f76e9f05cdbe013cdb0c9a37b434f6e594f5bd25e278908/numpy-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:389b85335838155a9076e9ad7f8fdba0827496ec2d2dc32ce69ce7898bde03ba", size = 20897025 },
+    { url = "https://files.pythonhosted.org/packages/2f/86/4ff04335901d6cf3a6bb9c748b0097546ae5af35e455ae9b962ebff4ecd7/numpy-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9498f60cd6bb8238d8eaf468a3d5bb031d34cd12556af53510f05fcf581c1b7e", size = 14129882 },
+    { url = "https://files.pythonhosted.org/packages/71/8d/a942cd4f959de7f08a79ab0c7e6cecb7431d5403dce78959a726f0f57aa1/numpy-2.3.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:622a65d40d8eb427d8e722fd410ac3ad4958002f109230bc714fa551044ebae2", size = 5110181 },
+    { url = "https://files.pythonhosted.org/packages/86/5d/45850982efc7b2c839c5626fb67fbbc520d5b0d7c1ba1ae3651f2f74c296/numpy-2.3.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:b9446d9d8505aadadb686d51d838f2b6688c9e85636a0c3abaeb55ed54756459", size = 6647581 },
+    { url = "https://files.pythonhosted.org/packages/1a/c0/c871d4a83f93b00373d3eebe4b01525eee8ef10b623a335ec262b58f4dc1/numpy-2.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:50080245365d75137a2bf46151e975de63146ae6d79f7e6bd5c0e85c9931d06a", size = 14262317 },
+    { url = "https://files.pythonhosted.org/packages/b7/f6/bc47f5fa666d5ff4145254f9e618d56e6a4ef9b874654ca74c19113bb538/numpy-2.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c24bb4113c66936eeaa0dc1e47c74770453d34f46ee07ae4efd853a2ed1ad10a", size = 16633919 },
+    { url = "https://files.pythonhosted.org/packages/f5/b4/65f48009ca0c9b76df5f404fccdea5a985a1bb2e34e97f21a17d9ad1a4ba/numpy-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4d8d294287fdf685281e671886c6dcdf0291a7c19db3e5cb4178d07ccf6ecc67", size = 15567651 },
+    { url = "https://files.pythonhosted.org/packages/f1/62/5367855a2018578e9334ed08252ef67cc302e53edc869666f71641cad40b/numpy-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6295f81f093b7f5769d1728a6bd8bf7466de2adfa771ede944ce6711382b89dc", size = 18361723 },
+    { url = "https://files.pythonhosted.org/packages/d4/75/5baed8cd867eabee8aad1e74d7197d73971d6a3d40c821f1848b8fab8b84/numpy-2.3.0-cp312-cp312-win32.whl", hash = "sha256:e6648078bdd974ef5d15cecc31b0c410e2e24178a6e10bf511e0557eed0f2570", size = 6318285 },
+    { url = "https://files.pythonhosted.org/packages/bc/49/d5781eaa1a15acb3b3a3f49dc9e2ff18d92d0ce5c2976f4ab5c0a7360250/numpy-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:0898c67a58cdaaf29994bc0e2c65230fd4de0ac40afaf1584ed0b02cd74c6fdd", size = 12732594 },
+    { url = "https://files.pythonhosted.org/packages/c2/1c/6d343e030815c7c97a1f9fbad00211b47717c7fe446834c224bd5311e6f1/numpy-2.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:bd8df082b6c4695753ad6193018c05aac465d634834dca47a3ae06d4bb22d9ea", size = 9891498 },
+    { url = "https://files.pythonhosted.org/packages/73/fc/1d67f751fd4dbafc5780244fe699bc4084268bad44b7c5deb0492473127b/numpy-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5754ab5595bfa2c2387d241296e0381c21f44a4b90a776c3c1d39eede13a746a", size = 20889633 },
+    { url = "https://files.pythonhosted.org/packages/e8/95/73ffdb69e5c3f19ec4530f8924c4386e7ba097efc94b9c0aff607178ad94/numpy-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d11fa02f77752d8099573d64e5fe33de3229b6632036ec08f7080f46b6649959", size = 14151683 },
+    { url = "https://files.pythonhosted.org/packages/64/d5/06d4bb31bb65a1d9c419eb5676173a2f90fd8da3c59f816cc54c640ce265/numpy-2.3.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:aba48d17e87688a765ab1cd557882052f238e2f36545dfa8e29e6a91aef77afe", size = 5102683 },
+    { url = "https://files.pythonhosted.org/packages/12/8b/6c2cef44f8ccdc231f6b56013dff1d71138c48124334aded36b1a1b30c5a/numpy-2.3.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4dc58865623023b63b10d52f18abaac3729346a7a46a778381e0e3af4b7f3beb", size = 6640253 },
+    { url = "https://files.pythonhosted.org/packages/62/aa/fca4bf8de3396ddb59544df9b75ffe5b73096174de97a9492d426f5cd4aa/numpy-2.3.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:df470d376f54e052c76517393fa443758fefcdd634645bc9c1f84eafc67087f0", size = 14258658 },
+    { url = "https://files.pythonhosted.org/packages/1c/12/734dce1087eed1875f2297f687e671cfe53a091b6f2f55f0c7241aad041b/numpy-2.3.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:87717eb24d4a8a64683b7a4e91ace04e2f5c7c77872f823f02a94feee186168f", size = 16628765 },
+    { url = "https://files.pythonhosted.org/packages/48/03/ffa41ade0e825cbcd5606a5669962419528212a16082763fc051a7247d76/numpy-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d8fa264d56882b59dcb5ea4d6ab6f31d0c58a57b41aec605848b6eb2ef4a43e8", size = 15564335 },
+    { url = "https://files.pythonhosted.org/packages/07/58/869398a11863310aee0ff85a3e13b4c12f20d032b90c4b3ee93c3b728393/numpy-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e651756066a0eaf900916497e20e02fe1ae544187cb0fe88de981671ee7f6270", size = 18360608 },
+    { url = "https://files.pythonhosted.org/packages/2f/8a/5756935752ad278c17e8a061eb2127c9a3edf4ba2c31779548b336f23c8d/numpy-2.3.0-cp313-cp313-win32.whl", hash = "sha256:e43c3cce3b6ae5f94696669ff2a6eafd9a6b9332008bafa4117af70f4b88be6f", size = 6310005 },
+    { url = "https://files.pythonhosted.org/packages/08/60/61d60cf0dfc0bf15381eaef46366ebc0c1a787856d1db0c80b006092af84/numpy-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:81ae0bf2564cf475f94be4a27ef7bcf8af0c3e28da46770fc904da9abd5279b5", size = 12729093 },
+    { url = "https://files.pythonhosted.org/packages/66/31/2f2f2d2b3e3c32d5753d01437240feaa32220b73258c9eef2e42a0832866/numpy-2.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:c8738baa52505fa6e82778580b23f945e3578412554d937093eac9205e845e6e", size = 9885689 },
+    { url = "https://files.pythonhosted.org/packages/f1/89/c7828f23cc50f607ceb912774bb4cff225ccae7131c431398ad8400e2c98/numpy-2.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39b27d8b38942a647f048b675f134dd5a567f95bfff481f9109ec308515c51d8", size = 20986612 },
+    { url = "https://files.pythonhosted.org/packages/dd/46/79ecf47da34c4c50eedec7511e53d57ffdfd31c742c00be7dc1d5ffdb917/numpy-2.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0eba4a1ea88f9a6f30f56fdafdeb8da3774349eacddab9581a21234b8535d3d3", size = 14298953 },
+    { url = "https://files.pythonhosted.org/packages/59/44/f6caf50713d6ff4480640bccb2a534ce1d8e6e0960c8f864947439f0ee95/numpy-2.3.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b0f1f11d0a1da54927436505a5a7670b154eac27f5672afc389661013dfe3d4f", size = 5225806 },
+    { url = "https://files.pythonhosted.org/packages/a6/43/e1fd1aca7c97e234dd05e66de4ab7a5be54548257efcdd1bc33637e72102/numpy-2.3.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:690d0a5b60a47e1f9dcec7b77750a4854c0d690e9058b7bef3106e3ae9117808", size = 6735169 },
+    { url = "https://files.pythonhosted.org/packages/84/89/f76f93b06a03177c0faa7ca94d0856c4e5c4bcaf3c5f77640c9ed0303e1c/numpy-2.3.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:8b51ead2b258284458e570942137155978583e407babc22e3d0ed7af33ce06f8", size = 14330701 },
+    { url = "https://files.pythonhosted.org/packages/aa/f5/4858c3e9ff7a7d64561b20580cf7cc5d085794bd465a19604945d6501f6c/numpy-2.3.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:aaf81c7b82c73bd9b45e79cfb9476cb9c29e937494bfe9092c26aece812818ad", size = 16692983 },
+    { url = "https://files.pythonhosted.org/packages/08/17/0e3b4182e691a10e9483bcc62b4bb8693dbf9ea5dc9ba0b77a60435074bb/numpy-2.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f420033a20b4f6a2a11f585f93c843ac40686a7c3fa514060a97d9de93e5e72b", size = 15641435 },
+    { url = "https://files.pythonhosted.org/packages/4e/d5/463279fda028d3c1efa74e7e8d507605ae87f33dbd0543cf4c4527c8b882/numpy-2.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d344ca32ab482bcf8735d8f95091ad081f97120546f3d250240868430ce52555", size = 18433798 },
+    { url = "https://files.pythonhosted.org/packages/0e/1e/7a9d98c886d4c39a2b4d3a7c026bffcf8fbcaf518782132d12a301cfc47a/numpy-2.3.0-cp313-cp313t-win32.whl", hash = "sha256:48a2e8eaf76364c32a1feaa60d6925eaf32ed7a040183b807e02674305beef61", size = 6438632 },
+    { url = "https://files.pythonhosted.org/packages/fe/ab/66fc909931d5eb230107d016861824f335ae2c0533f422e654e5ff556784/numpy-2.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ba17f93a94e503551f154de210e4d50c5e3ee20f7e7a1b5f6ce3f22d419b93bb", size = 12868491 },
+    { url = "https://files.pythonhosted.org/packages/ee/e8/2c8a1c9e34d6f6d600c83d5ce5b71646c32a13f34ca5c518cc060639841c/numpy-2.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f14e016d9409680959691c109be98c436c6249eaf7f118b424679793607b5944", size = 9935345 },
+    { url = "https://files.pythonhosted.org/packages/6a/a2/f8c1133f90eaa1c11bbbec1dc28a42054d0ce74bc2c9838c5437ba5d4980/numpy-2.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:80b46117c7359de8167cc00a2c7d823bdd505e8c7727ae0871025a86d668283b", size = 21070759 },
+    { url = "https://files.pythonhosted.org/packages/6c/e0/4c05fc44ba28463096eee5ae2a12832c8d2759cc5bcec34ae33386d3ff83/numpy-2.3.0-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:5814a0f43e70c061f47abd5857d120179609ddc32a613138cbb6c4e9e2dbdda5", size = 5301054 },
+    { url = "https://files.pythonhosted.org/packages/8a/3b/6c06cdebe922bbc2a466fe2105f50f661238ea223972a69c7deb823821e7/numpy-2.3.0-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:ef6c1e88fd6b81ac6d215ed71dc8cd027e54d4bf1d2682d362449097156267a2", size = 6817520 },
+    { url = "https://files.pythonhosted.org/packages/9d/a3/1e536797fd10eb3c5dbd2e376671667c9af19e241843548575267242ea02/numpy-2.3.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:33a5a12a45bb82d9997e2c0b12adae97507ad7c347546190a18ff14c28bbca12", size = 14398078 },
+    { url = "https://files.pythonhosted.org/packages/7c/61/9d574b10d9368ecb1a0c923952aa593510a20df4940aa615b3a71337c8db/numpy-2.3.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:54dfc8681c1906d239e95ab1508d0a533c4a9505e52ee2d71a5472b04437ef97", size = 16751324 },
+    { url = "https://files.pythonhosted.org/packages/39/de/bcad52ce972dc26232629ca3a99721fd4b22c1d2bda84d5db6541913ef9c/numpy-2.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e017a8a251ff4d18d71f139e28bdc7c31edba7a507f72b1414ed902cbe48c74d", size = 12924237 },
+]
+
 [[package]]
 name = "orjson"
 version = "3.10.18"
@@ -522,50 +714,50 @@ wheels = [
 
 [[package]]
 name = "ormsgpack"
-version = "1.9.1"
+version = "1.10.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/25/a7/462cf8ff5e29241868b82d3a5ec124d690eb6a6a5c6fa5bb1367b839e027/ormsgpack-1.9.1.tar.gz", hash = "sha256:3da6e63d82565e590b98178545e64f0f8506137b92bd31a2d04fd7c82baf5794", size = 56887 }
+sdist = { url = "https://files.pythonhosted.org/packages/92/36/44eed5ef8ce93cded76a576780bab16425ce7876f10d3e2e6265e46c21ea/ormsgpack-1.10.0.tar.gz", hash = "sha256:7f7a27efd67ef22d7182ec3b7fa7e9d147c3ad9be2a24656b23c989077e08b16", size = 58629 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/32/5f504c0695ff96aaaf0452bee522d79b5a3ee809f22fd77fdb0dd5756d86/ormsgpack-1.9.1-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:f1f804fd9c0fd84213a6022c34172f82323b34afa7052a4af18797582cf56365", size = 382793 },
-    { url = "https://files.pythonhosted.org/packages/1e/c6/64fe1270271b61495611f1d3068baedb57d76e0f93ce7156f3763fb79b32/ormsgpack-1.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eab5cec99c46276b37071d570aab98603f3d0309b3818da3247eb64bb95e5cfc", size = 213974 },
-    { url = "https://files.pythonhosted.org/packages/13/56/6666d6a9b82c7d2021fce6823ff823bc373a4e7280979c1b453317678fbc/ormsgpack-1.9.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c12c6bb30e6df6fc0213b77f0a5e143f371d618be2e8eb4d555340ce01c6900", size = 217200 },
-    { url = "https://files.pythonhosted.org/packages/5f/fb/b844ed1e69d8615163525a8403d7abd3548b3fbfa0f3a973808f36145a0f/ormsgpack-1.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:994d4bbb7ee333264a3e55e30ccee063df6635d785f21a08bf52f67821454a51", size = 223648 },
-    { url = "https://files.pythonhosted.org/packages/f2/26/c40c3e300f9c61a5ed7a6921656dd0d2907a8174936e1e643677585e497c/ormsgpack-1.9.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a668a584cf4bb6e1a6ef5a35f3f0d0fdae80cfb7237344ad19a50cce8c79317b", size = 394197 },
-    { url = "https://files.pythonhosted.org/packages/2d/4c/7a4ae187f18e7abf7ab0662b473264a60a5aa4e9bff266f541a8855df163/ormsgpack-1.9.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:aaf77699203822638014c604d100f132583844d4fd01eb639a2266970c02cfdf", size = 480550 },
-    { url = "https://files.pythonhosted.org/packages/b1/33/5c465dfd5571f816835bb9e371987bf081b529c64ef28a72d18b0b59902d/ormsgpack-1.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:003d7e1992b447898caf25a820b3037ec68a57864b3e2f34b64693b7d60a9984", size = 396955 },
-    { url = "https://files.pythonhosted.org/packages/8f/fd/8f64f477b5c6d66e9c6343d7d3f32d7063ba20ab151dd36884e6504899ab/ormsgpack-1.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:67fefc77e4ba9469f79426769eb4c78acf21f22bef3ab1239a72dd728036ffc2", size = 125102 },
-    { url = "https://files.pythonhosted.org/packages/d8/3b/388e7915a28db6ab3daedfd4937bd7b063c50dd1543068daa31c0a3b70ed/ormsgpack-1.9.1-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:16eaf32c33ab4249e242181d59e2509b8e0330d6f65c1d8bf08c3dea38fd7c02", size = 382794 },
-    { url = "https://files.pythonhosted.org/packages/0f/b4/3f4afba058822bf69b274e0defe507056be0340e65363c3ebcd312b01b84/ormsgpack-1.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c70f2e5b2f9975536e8f7936a9721601dc54febe363d2d82f74c9b31d4fe1c65", size = 213974 },
-    { url = "https://files.pythonhosted.org/packages/bf/be/f0e21366d51b6e28fc3a55425be6a125545370d3479bf25be081e83ee236/ormsgpack-1.9.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:17c9e18b07d69e3db2e0f8af4731040175e11bdfde78ad8e28126e9e66ec5167", size = 217200 },
-    { url = "https://files.pythonhosted.org/packages/cc/90/67a23c1c880a6e5552acb45f9555b642528f89c8bcf75283a2ea64ef7175/ormsgpack-1.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73538d749096bb6470328601a2be8f7bdec28849ec6fd19595c232a5848d7124", size = 223649 },
-    { url = "https://files.pythonhosted.org/packages/80/ad/116c1f970b5b4453e4faa52645517a2e5eaf1ab385ba09a5c54253d07d0e/ormsgpack-1.9.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:827ff71de228cfd6d07b9d6b47911aa61b1e8dc995dec3caf8fdcdf4f874bcd0", size = 394200 },
-    { url = "https://files.pythonhosted.org/packages/c5/a2/b224a5ef193628a15205e473179276b87e8290d321693e4934a05cbd6ccf/ormsgpack-1.9.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7307f808b3df282c8e8ed92c6ebceeb3eea3d8eeec808438f3f212226b25e217", size = 480551 },
-    { url = "https://files.pythonhosted.org/packages/b5/f4/a0f528196af6ab46e6c3f3051cf7403016bdc7b7d3e673ea5b04b145be98/ormsgpack-1.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f30aad7fb083bed1c540a3c163c6a9f63a94e3c538860bf8f13386c29b560ad5", size = 396959 },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/60c6f4787e3e93f5eb34fccb163753a8771465983a579e3405152f2422fd/ormsgpack-1.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:829a1b4c5bc3c38ece0c55cf91ebc09c3b987fceb24d3f680c2bcd03fd3789a4", size = 125100 },
-    { url = "https://files.pythonhosted.org/packages/dd/f1/155a598cc8030526ccaaf91ba4d61530f87900645559487edba58b0a90a2/ormsgpack-1.9.1-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:1ede445fc3fdba219bb0e0d1f289df26a9c7602016b7daac6fafe8fe4e91548f", size = 383225 },
-    { url = "https://files.pythonhosted.org/packages/23/1c/ef3097ba550fad55c79525f461febdd4e0d9cc18d065248044536f09488e/ormsgpack-1.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db50b9f918e25b289114312ed775794d0978b469831b992bdc65bfe20b91fe30", size = 214056 },
-    { url = "https://files.pythonhosted.org/packages/27/77/64d0da25896b2cbb99505ca518c109d7dd1964d7fde14c10943731738b60/ormsgpack-1.9.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c7d8fc58e4333308f58ec720b1ee6b12b2b3fe2d2d8f0766ab751cb351e8757", size = 217339 },
-    { url = "https://files.pythonhosted.org/packages/6c/10/c3a7fd0a0068b0bb52cccbfeb5656db895d69e895a3abbc210c4b3f98ff8/ormsgpack-1.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aeee6d08c040db265cb8563444aba343ecb32cbdbe2414a489dcead9f70c6765", size = 223816 },
-    { url = "https://files.pythonhosted.org/packages/43/e7/aee1238dba652f2116c2523d36fd1c5f9775436032be5c233108fd2a1415/ormsgpack-1.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2fbb8181c198bdc413a4e889e5200f010724eea4b6d5a9a7eee2df039ac04aca", size = 394287 },
-    { url = "https://files.pythonhosted.org/packages/c7/09/1b452a92376f29d7a2da7c18fb01cf09978197a8eccbb8b204e72fd5a970/ormsgpack-1.9.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:16488f094ac0e2250cceea6caf72962614aa432ee11dd57ef45e1ad25ece3eff", size = 480709 },
-    { url = "https://files.pythonhosted.org/packages/de/13/7fa9fee5a73af8a73a42bf8c2e69489605714f65f5a41454400a05e84a3b/ormsgpack-1.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:422d960bfd6ad88be20794f50ec7953d8f7a0f2df60e19d0e8feb994e2ed64ee", size = 397247 },
-    { url = "https://files.pythonhosted.org/packages/a1/2d/2e87cb28110db0d3bb750edd4d8719b5068852a2eef5e96b0bf376bb8a81/ormsgpack-1.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:e6e2f9eab527cf43fb4a4293e493370276b1c8716cf305689202d646c6a782ef", size = 125368 },
-    { url = "https://files.pythonhosted.org/packages/b8/54/0390d5d092831e4df29dbafe32402891fc14b3e6ffe5a644b16cbbc9d9bc/ormsgpack-1.9.1-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:ac61c18d9dd085e8519b949f7e655f7fb07909fd09c53b4338dd33309012e289", size = 383226 },
-    { url = "https://files.pythonhosted.org/packages/47/64/8b15d262d1caefead8fb22ec144f5ff7d9505fc31c22bc34598053d46fbe/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134840b8c6615da2c24ce77bd12a46098015c808197a9995c7a2d991e1904eec", size = 214057 },
-    { url = "https://files.pythonhosted.org/packages/57/00/65823609266bad4d5ed29ea753d24a3bdb01c7edaf923da80967fc31f9c5/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38fd42618f626394b2c7713c5d4bcbc917254e9753d5d4cde460658b51b11a74", size = 217340 },
-    { url = "https://files.pythonhosted.org/packages/a0/51/e535c50f7f87b49110233647f55300d7975139ef5e51f1adb4c55f58c124/ormsgpack-1.9.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d36397333ad07b9eba4c2e271fa78951bd81afc059c85a6e9f6c0eb2de07cda", size = 223815 },
-    { url = "https://files.pythonhosted.org/packages/0c/ee/393e4a6de2a62124bf589602648f295a9fb3907a0e2fe80061b88899d072/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:603063089597917d04e4c1b1d53988a34f7dc2ff1a03adcfd1cf4ae966d5fba6", size = 394287 },
-    { url = "https://files.pythonhosted.org/packages/c6/d8/e56d7c3cb73a0e533e3e2a21ae5838b2aa36a9dac1ca9c861af6bae5a369/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:94bbf2b185e0cb721ceaba20e64b7158e6caf0cecd140ca29b9f05a8d5e91e2f", size = 480707 },
-    { url = "https://files.pythonhosted.org/packages/e6/e0/6a3c6a6dc98583a721c54b02f5195bde8f801aebdeda9b601fa2ab30ad39/ormsgpack-1.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c38f380b1e8c96a712eb302b9349347385161a8e29046868ae2bfdfcb23e2692", size = 397246 },
-    { url = "https://files.pythonhosted.org/packages/b0/60/0ee5d790f13507e1f75ac21fc82dc1ef29afe1f520bd0f249d65b2f4839b/ormsgpack-1.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:a4bc63fb30db94075611cedbbc3d261dd17cf2aa8ff75a0fd684cd45ca29cb1b", size = 125371 },
-    { url = "https://files.pythonhosted.org/packages/85/02/ac4a2263c9aad0d455f240e1bdd41b443e5452257cf13bc188177b0dfd1f/ormsgpack-1.9.1-cp39-cp39-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:e95909248bece8e88a310a913838f17ff5a39190aa4e61de909c3cd27f59744b", size = 382789 },
-    { url = "https://files.pythonhosted.org/packages/81/6f/e50d070ae3a6aa7cb50849d0796ac6d72c0f8f01d5a42438c9567ab352e3/ormsgpack-1.9.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3939188810c5c641d6b207f29994142ae2b1c70534f7839bbd972d857ac2072", size = 213967 },
-    { url = "https://files.pythonhosted.org/packages/55/1d/379734bca4f2d71ce11c7096d85276280cf13d1bb7243bf809b171c25cda/ormsgpack-1.9.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b6476344a585aea00a2acc9fd07355bf2daac04062cfdd480fa83ec3e2403b", size = 217183 },
-    { url = "https://files.pythonhosted.org/packages/9a/f6/036a44ada8659b1729db5f20ba50dc1945a84a50cd4fa6b3a74d0f16fab9/ormsgpack-1.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7d8b9d53da82b31662ce5a3834b65479cf794a34befb9fc50baa51518383250", size = 223647 },
-    { url = "https://files.pythonhosted.org/packages/b9/61/5c8671ab3b7cac21076169972bad9f4faa1fdda1f70e0ae78b365894b164/ormsgpack-1.9.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:3933d4b0c0d404ee234dbc372836d6f2d2f4b6330c2a2fb9709ba4eaebfae7ba", size = 394232 },
-    { url = "https://files.pythonhosted.org/packages/7b/70/6e9ba8c8c405dee5dffd86edf1188ef1a116421598e18df89dac0c499aae/ormsgpack-1.9.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:f824e94a7969f0aee9a6847ec232cf731a03b8734951c2a774dd4762308ea2d2", size = 480582 },
-    { url = "https://files.pythonhosted.org/packages/a6/e1/2113022dd9236cea13f0ba850a5f8a640c0c9e3b07bfbbaf01409190068b/ormsgpack-1.9.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c1f3f2295374020f9650e4aa7af6403ff016a0d92778b4a48bb3901fd801232d", size = 396952 },
-    { url = "https://files.pythonhosted.org/packages/01/d4/58ca5de3124ac975dae1a96a475c3cb9ed70c70dfba39fd4ceca53838ee6/ormsgpack-1.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:92eb1b4f7b168da47f547329b4b58d16d8f19508a97ce5266567385d42d81968", size = 125107 },
+    { url = "https://files.pythonhosted.org/packages/fc/74/c2dd5daf069e3798d09d5746000f9b210de04df83834e5cb47f0ace51892/ormsgpack-1.10.0-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8a52c7ce7659459f3dc8dec9fd6a6c76f855a0a7e2b61f26090982ac10b95216", size = 376280 },
+    { url = "https://files.pythonhosted.org/packages/78/7b/30ff4bffb709e8a242005a8c4d65714fd96308ad640d31cff1b85c0d8cc4/ormsgpack-1.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:060f67fe927582f4f63a1260726d019204b72f460cf20930e6c925a1d129f373", size = 204335 },
+    { url = "https://files.pythonhosted.org/packages/8f/3f/c95b7d142819f801a0acdbd04280e8132e43b6e5a8920173e8eb92ea0e6a/ormsgpack-1.10.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7058ef6092f995561bf9f71d6c9a4da867b6cc69d2e94cb80184f579a3ceed5", size = 215373 },
+    { url = "https://files.pythonhosted.org/packages/ef/1a/e30f4bcf386db2015d1686d1da6110c95110294d8ea04f86091dd5eb3361/ormsgpack-1.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f6f3509c1b0e51b15552d314b1d409321718122e90653122ce4b997f01453a", size = 216469 },
+    { url = "https://files.pythonhosted.org/packages/96/fc/7e44aeade22b91883586f45b7278c118fd210834c069774891447f444fc9/ormsgpack-1.10.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c1edafd5c72b863b1f875ec31c529f09c872a5ff6fe473b9dfaf188ccc3227", size = 384590 },
+    { url = "https://files.pythonhosted.org/packages/ec/78/f92c24e8446697caa83c122f10b6cf5e155eddf81ce63905c8223a260482/ormsgpack-1.10.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c780b44107a547a9e9327270f802fa4d6b0f6667c9c03c3338c0ce812259a0f7", size = 478891 },
+    { url = "https://files.pythonhosted.org/packages/5a/75/87449690253c64bea2b663c7c8f2dbc9ad39d73d0b38db74bdb0f3947b16/ormsgpack-1.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:137aab0d5cdb6df702da950a80405eb2b7038509585e32b4e16289604ac7cb84", size = 390121 },
+    { url = "https://files.pythonhosted.org/packages/69/cc/c83257faf3a5169ec29dd87121317a25711da9412ee8c1e82f2e1a00c0be/ormsgpack-1.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:3e666cb63030538fa5cd74b1e40cb55b6fdb6e2981f024997a288bf138ebad07", size = 121196 },
+    { url = "https://files.pythonhosted.org/packages/30/27/7da748bc0d7d567950a378dee5a32477ed5d15462ab186918b5f25cac1ad/ormsgpack-1.10.0-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:4bb7df307e17b36cbf7959cd642c47a7f2046ae19408c564e437f0ec323a7775", size = 376275 },
+    { url = "https://files.pythonhosted.org/packages/7b/65/c082cc8c74a914dbd05af0341c761c73c3d9960b7432bbf9b8e1e20811af/ormsgpack-1.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8817ae439c671779e1127ee62f0ac67afdeaeeacb5f0db45703168aa74a2e4af", size = 204335 },
+    { url = "https://files.pythonhosted.org/packages/46/62/17ef7e5d9766c79355b9c594cc9328c204f1677bc35da0595cc4e46449f0/ormsgpack-1.10.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2f345f81e852035d80232e64374d3a104139d60f8f43c6c5eade35c4bac5590e", size = 215372 },
+    { url = "https://files.pythonhosted.org/packages/4e/92/7c91e8115fc37e88d1a35e13200fda3054ff5d2e5adf017345e58cea4834/ormsgpack-1.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21de648a1c7ef692bdd287fb08f047bd5371d7462504c0a7ae1553c39fee35e3", size = 216470 },
+    { url = "https://files.pythonhosted.org/packages/2c/86/ce053c52e2517b90e390792d83e926a7a523c1bce5cc63d0a7cd05ce6cf6/ormsgpack-1.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3a7d844ae9cbf2112c16086dd931b2acefce14cefd163c57db161170c2bfa22b", size = 384591 },
+    { url = "https://files.pythonhosted.org/packages/07/e8/2ad59f2ab222c6029e500bc966bfd2fe5cb099f8ab6b7ebeb50ddb1a6fe5/ormsgpack-1.10.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e4d80585403d86d7f800cf3d0aafac1189b403941e84e90dd5102bb2b92bf9d5", size = 478892 },
+    { url = "https://files.pythonhosted.org/packages/f4/73/f55e4b47b7b18fd8e7789680051bf830f1e39c03f1d9ed993cd0c3e97215/ormsgpack-1.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:da1de515a87e339e78a3ccf60e39f5fb740edac3e9e82d3c3d209e217a13ac08", size = 390122 },
+    { url = "https://files.pythonhosted.org/packages/f7/87/073251cdb93d4c6241748568b3ad1b2a76281fb2002eed16a3a4043d61cf/ormsgpack-1.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:57c4601812684024132cbb32c17a7d4bb46ffc7daf2fddf5b697391c2c4f142a", size = 121197 },
+    { url = "https://files.pythonhosted.org/packages/99/95/f3ab1a7638f6aa9362e87916bb96087fbbc5909db57e19f12ad127560e1e/ormsgpack-1.10.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:4e159d50cd4064d7540e2bc6a0ab66eab70b0cc40c618b485324ee17037527c0", size = 376806 },
+    { url = "https://files.pythonhosted.org/packages/6c/2b/42f559f13c0b0f647b09d749682851d47c1a7e48308c43612ae6833499c8/ormsgpack-1.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb47c85f3a866e29279d801115b554af0fefc409e2ed8aa90aabfa77efe5cc6", size = 204433 },
+    { url = "https://files.pythonhosted.org/packages/45/42/1ca0cb4d8c80340a89a4af9e6d8951fb8ba0d076a899d2084eadf536f677/ormsgpack-1.10.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c28249574934534c9bd5dce5485c52f21bcea0ee44d13ece3def6e3d2c3798b5", size = 215547 },
+    { url = "https://files.pythonhosted.org/packages/0a/38/184a570d7c44c0260bc576d1daaac35b2bfd465a50a08189518505748b9a/ormsgpack-1.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1957dcadbb16e6a981cd3f9caef9faf4c2df1125e2a1b702ee8236a55837ce07", size = 216746 },
+    { url = "https://files.pythonhosted.org/packages/69/2f/1aaffd08f6b7fdc2a57336a80bdfb8df24e6a65ada5aa769afecfcbc6cc6/ormsgpack-1.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b29412558c740bf6bac156727aa85ac67f9952cd6f071318f29ee72e1a76044", size = 384783 },
+    { url = "https://files.pythonhosted.org/packages/a9/63/3e53d6f43bb35e00c98f2b8ab2006d5138089ad254bc405614fbf0213502/ormsgpack-1.10.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6933f350c2041ec189fe739f0ba7d6117c8772f5bc81f45b97697a84d03020dd", size = 479076 },
+    { url = "https://files.pythonhosted.org/packages/b8/19/fa1121b03b61402bb4d04e35d164e2320ef73dfb001b57748110319dd014/ormsgpack-1.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a86de06d368fcc2e58b79dece527dc8ca831e0e8b9cec5d6e633d2777ec93d0", size = 390447 },
+    { url = "https://files.pythonhosted.org/packages/b0/0d/73143ecb94ac4a5dcba223402139240a75dee0cc6ba8a543788a5646407a/ormsgpack-1.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:35fa9f81e5b9a0dab42e09a73f7339ecffdb978d6dbf9deb2ecf1e9fc7808722", size = 121401 },
+    { url = "https://files.pythonhosted.org/packages/61/f8/ec5f4e03268d0097545efaab2893aa63f171cf2959cb0ea678a5690e16a1/ormsgpack-1.10.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d816d45175a878993b7372bd5408e0f3ec5a40f48e2d5b9d8f1cc5d31b61f1f", size = 376806 },
+    { url = "https://files.pythonhosted.org/packages/c1/19/b3c53284aad1e90d4d7ed8c881a373d218e16675b8b38e3569d5b40cc9b8/ormsgpack-1.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a90345ccb058de0f35262893751c603b6376b05f02be2b6f6b7e05d9dd6d5643", size = 204433 },
+    { url = "https://files.pythonhosted.org/packages/09/0b/845c258f59df974a20a536c06cace593698491defdd3d026a8a5f9b6e745/ormsgpack-1.10.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:144b5e88f1999433e54db9d637bae6fe21e935888be4e3ac3daecd8260bd454e", size = 215549 },
+    { url = "https://files.pythonhosted.org/packages/61/56/57fce8fb34ca6c9543c026ebebf08344c64dbb7b6643d6ddd5355d37e724/ormsgpack-1.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2190b352509d012915921cca76267db136cd026ddee42f1b0d9624613cc7058c", size = 216747 },
+    { url = "https://files.pythonhosted.org/packages/b8/3f/655b5f6a2475c8d209f5348cfbaaf73ce26237b92d79ef2ad439407dd0fa/ormsgpack-1.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:86fd9c1737eaba43d3bb2730add9c9e8b5fbed85282433705dd1b1e88ea7e6fb", size = 384785 },
+    { url = "https://files.pythonhosted.org/packages/4b/94/687a0ad8afd17e4bce1892145d6a1111e58987ddb176810d02a1f3f18686/ormsgpack-1.10.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:33afe143a7b61ad21bb60109a86bb4e87fec70ef35db76b89c65b17e32da7935", size = 479076 },
+    { url = "https://files.pythonhosted.org/packages/c8/34/68925232e81e0e062a2f0ac678f62aa3b6f7009d6a759e19324dbbaebae7/ormsgpack-1.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f23d45080846a7b90feabec0d330a9cc1863dc956728412e4f7986c80ab3a668", size = 390446 },
+    { url = "https://files.pythonhosted.org/packages/12/ad/f4e1a36a6d1714afb7ffb74b3ababdcb96529cf4e7a216f9f7c8eda837b6/ormsgpack-1.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:534d18acb805c75e5fba09598bf40abe1851c853247e61dda0c01f772234da69", size = 121399 },
+    { url = "https://files.pythonhosted.org/packages/75/8f/bb80469db9d5b10708cba6997463d140486ca7053a5d18f99b5739cfecf7/ormsgpack-1.10.0-cp39-cp39-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:efdb25cf6d54085f7ae557268d59fd2d956f1a09a340856e282d2960fe929f32", size = 376272 },
+    { url = "https://files.pythonhosted.org/packages/08/9c/48f714ed3d5a153f25e3b490496e6ba214aee265a82be1b61e39019ea146/ormsgpack-1.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddfcb30d4b1be2439836249d675f297947f4fb8efcd3eeb6fd83021d773cadc4", size = 204314 },
+    { url = "https://files.pythonhosted.org/packages/27/42/7f9edf6e5511120b5304c76c5d3a8b4719ff927555a6dba41b6f9d041b30/ormsgpack-1.10.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee0944b6ccfd880beb1ca29f9442a774683c366f17f4207f8b81c5e24cadb453", size = 215386 },
+    { url = "https://files.pythonhosted.org/packages/40/87/41e14485857fbe4ed5a530677fe60dd6910a254825c0b1cb5b04baaa4be0/ormsgpack-1.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:35cdff6a0d3ba04e40a751129763c3b9b57a602c02944138e4b760ec99ae80a1", size = 216466 },
+    { url = "https://files.pythonhosted.org/packages/cb/68/769fa1c721d8aa6799c0ce98b1711ae57de3e6379b554ebf9a11be4c62ff/ormsgpack-1.10.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:599ccdabc19c618ef5de6e6f2e7f5d48c1f531a625fa6772313b8515bc710681", size = 384600 },
+    { url = "https://files.pythonhosted.org/packages/4e/f9/b57fd387fe16753783a3cea0ed2471c727bbed4356d8a08e3f0340251870/ormsgpack-1.10.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:bf46f57da9364bd5eefd92365c1b78797f56c6f780581eecd60cd7b367f9b4d3", size = 478888 },
+    { url = "https://files.pythonhosted.org/packages/3e/0f/464cdfa7f9ee817c2d94485880b6c3c4b9f22df9fcbf21c303bbfebcb3ed/ormsgpack-1.10.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b796f64fdf823dedb1e35436a4a6f889cf78b1aa42d3097c66e5adfd8c3bd72d", size = 390118 },
+    { url = "https://files.pythonhosted.org/packages/ad/03/b9146dff5458def4c0a2b1e35c1c24e4d5e8083899aa0718b6eccba39317/ormsgpack-1.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:106253ac9dc08520951e556b3c270220fcb8b4fef0d30b71eedac4befa4de749", size = 121199 },
 ]
 
 [[package]]
@@ -577,6 +769,63 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
 ]
 
+[[package]]
+name = "pandas"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" },
+    { name = "numpy", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/51/48f713c4c728d7c55ef7444ba5ea027c26998d96d1a40953b346438602fc/pandas-2.3.0.tar.gz", hash = "sha256:34600ab34ebf1131a7613a260a61dbe8b62c188ec0ea4c296da7c9a06b004133", size = 4484490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/2d/df6b98c736ba51b8eaa71229e8fcd91233a831ec00ab520e1e23090cc072/pandas-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:625466edd01d43b75b1883a64d859168e4556261a5035b32f9d743b67ef44634", size = 11527531 },
+    { url = "https://files.pythonhosted.org/packages/77/1c/3f8c331d223f86ba1d0ed7d3ed7fcf1501c6f250882489cc820d2567ddbf/pandas-2.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a6872d695c896f00df46b71648eea332279ef4077a409e2fe94220208b6bb675", size = 10774764 },
+    { url = "https://files.pythonhosted.org/packages/1b/45/d2599400fad7fe06b849bd40b52c65684bc88fbe5f0a474d0513d057a377/pandas-2.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4dd97c19bd06bc557ad787a15b6489d2614ddaab5d104a0310eb314c724b2d2", size = 11711963 },
+    { url = "https://files.pythonhosted.org/packages/66/f8/5508bc45e994e698dbc93607ee6b9b6eb67df978dc10ee2b09df80103d9e/pandas-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:034abd6f3db8b9880aaee98f4f5d4dbec7c4829938463ec046517220b2f8574e", size = 12349446 },
+    { url = "https://files.pythonhosted.org/packages/f7/fc/17851e1b1ea0c8456ba90a2f514c35134dd56d981cf30ccdc501a0adeac4/pandas-2.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23c2b2dc5213810208ca0b80b8666670eb4660bbfd9d45f58592cc4ddcfd62e1", size = 12920002 },
+    { url = "https://files.pythonhosted.org/packages/a1/9b/8743be105989c81fa33f8e2a4e9822ac0ad4aaf812c00fee6bb09fc814f9/pandas-2.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:39ff73ec07be5e90330cc6ff5705c651ace83374189dcdcb46e6ff54b4a72cd6", size = 13651218 },
+    { url = "https://files.pythonhosted.org/packages/26/fa/8eeb2353f6d40974a6a9fd4081ad1700e2386cf4264a8f28542fd10b3e38/pandas-2.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:40cecc4ea5abd2921682b57532baea5588cc5f80f0231c624056b146887274d2", size = 11082485 },
+    { url = "https://files.pythonhosted.org/packages/96/1e/ba313812a699fe37bf62e6194265a4621be11833f5fce46d9eae22acb5d7/pandas-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8adff9f138fc614347ff33812046787f7d43b3cef7c0f0171b3340cae333f6ca", size = 11551836 },
+    { url = "https://files.pythonhosted.org/packages/1b/cc/0af9c07f8d714ea563b12383a7e5bde9479cf32413ee2f346a9c5a801f22/pandas-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e5f08eb9a445d07720776df6e641975665c9ea12c9d8a331e0f6890f2dcd76ef", size = 10807977 },
+    { url = "https://files.pythonhosted.org/packages/ee/3e/8c0fb7e2cf4a55198466ced1ca6a9054ae3b7e7630df7757031df10001fd/pandas-2.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa35c266c8cd1a67d75971a1912b185b492d257092bdd2709bbdebe574ed228d", size = 11788230 },
+    { url = "https://files.pythonhosted.org/packages/14/22/b493ec614582307faf3f94989be0f7f0a71932ed6f56c9a80c0bb4a3b51e/pandas-2.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14a0cc77b0f089d2d2ffe3007db58f170dae9b9f54e569b299db871a3ab5bf46", size = 12370423 },
+    { url = "https://files.pythonhosted.org/packages/9f/74/b012addb34cda5ce855218a37b258c4e056a0b9b334d116e518d72638737/pandas-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c06f6f144ad0a1bf84699aeea7eff6068ca5c63ceb404798198af7eb86082e33", size = 12990594 },
+    { url = "https://files.pythonhosted.org/packages/95/81/b310e60d033ab64b08e66c635b94076488f0b6ce6a674379dd5b224fc51c/pandas-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ed16339bc354a73e0a609df36d256672c7d296f3f767ac07257801aa064ff73c", size = 13745952 },
+    { url = "https://files.pythonhosted.org/packages/25/ac/f6ee5250a8881b55bd3aecde9b8cfddea2f2b43e3588bca68a4e9aaf46c8/pandas-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:fa07e138b3f6c04addfeaf56cc7fdb96c3b68a3fe5e5401251f231fce40a0d7a", size = 11094534 },
+    { url = "https://files.pythonhosted.org/packages/94/46/24192607058dd607dbfacdd060a2370f6afb19c2ccb617406469b9aeb8e7/pandas-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2eb4728a18dcd2908c7fccf74a982e241b467d178724545a48d0caf534b38ebf", size = 11573865 },
+    { url = "https://files.pythonhosted.org/packages/9f/cc/ae8ea3b800757a70c9fdccc68b67dc0280a6e814efcf74e4211fd5dea1ca/pandas-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9d8c3187be7479ea5c3d30c32a5d73d62a621166675063b2edd21bc47614027", size = 10702154 },
+    { url = "https://files.pythonhosted.org/packages/d8/ba/a7883d7aab3d24c6540a2768f679e7414582cc389876d469b40ec749d78b/pandas-2.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ff730713d4c4f2f1c860e36c005c7cefc1c7c80c21c0688fd605aa43c9fcf09", size = 11262180 },
+    { url = "https://files.pythonhosted.org/packages/01/a5/931fc3ad333d9d87b10107d948d757d67ebcfc33b1988d5faccc39c6845c/pandas-2.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba24af48643b12ffe49b27065d3babd52702d95ab70f50e1b34f71ca703e2c0d", size = 11991493 },
+    { url = "https://files.pythonhosted.org/packages/d7/bf/0213986830a92d44d55153c1d69b509431a972eb73f204242988c4e66e86/pandas-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:404d681c698e3c8a40a61d0cd9412cc7364ab9a9cc6e144ae2992e11a2e77a20", size = 12470733 },
+    { url = "https://files.pythonhosted.org/packages/a4/0e/21eb48a3a34a7d4bac982afc2c4eb5ab09f2d988bdf29d92ba9ae8e90a79/pandas-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6021910b086b3ca756755e86ddc64e0ddafd5e58e076c72cb1585162e5ad259b", size = 13212406 },
+    { url = "https://files.pythonhosted.org/packages/1f/d9/74017c4eec7a28892d8d6e31ae9de3baef71f5a5286e74e6b7aad7f8c837/pandas-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:094e271a15b579650ebf4c5155c05dcd2a14fd4fdd72cf4854b2f7ad31ea30be", size = 10976199 },
+    { url = "https://files.pythonhosted.org/packages/d3/57/5cb75a56a4842bbd0511c3d1c79186d8315b82dac802118322b2de1194fe/pandas-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c7e2fc25f89a49a11599ec1e76821322439d90820108309bf42130d2f36c983", size = 11518913 },
+    { url = "https://files.pythonhosted.org/packages/05/01/0c8785610e465e4948a01a059562176e4c8088aa257e2e074db868f86d4e/pandas-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c6da97aeb6a6d233fb6b17986234cc723b396b50a3c6804776351994f2a658fd", size = 10655249 },
+    { url = "https://files.pythonhosted.org/packages/e8/6a/47fd7517cd8abe72a58706aab2b99e9438360d36dcdb052cf917b7bf3bdc/pandas-2.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb32dc743b52467d488e7a7c8039b821da2826a9ba4f85b89ea95274f863280f", size = 11328359 },
+    { url = "https://files.pythonhosted.org/packages/2a/b3/463bfe819ed60fb7e7ddffb4ae2ee04b887b3444feee6c19437b8f834837/pandas-2.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:213cd63c43263dbb522c1f8a7c9d072e25900f6975596f883f4bebd77295d4f3", size = 12024789 },
+    { url = "https://files.pythonhosted.org/packages/04/0c/e0704ccdb0ac40aeb3434d1c641c43d05f75c92e67525df39575ace35468/pandas-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1d2b33e68d0ce64e26a4acc2e72d747292084f4e8db4c847c6f5f6cbe56ed6d8", size = 12480734 },
+    { url = "https://files.pythonhosted.org/packages/e9/df/815d6583967001153bb27f5cf075653d69d51ad887ebbf4cfe1173a1ac58/pandas-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:430a63bae10b5086995db1b02694996336e5a8ac9a96b4200572b413dfdfccb9", size = 13223381 },
+    { url = "https://files.pythonhosted.org/packages/79/88/ca5973ed07b7f484c493e941dbff990861ca55291ff7ac67c815ce347395/pandas-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4930255e28ff5545e2ca404637bcc56f031893142773b3468dc021c6c32a1390", size = 10970135 },
+    { url = "https://files.pythonhosted.org/packages/24/fb/0994c14d1f7909ce83f0b1fb27958135513c4f3f2528bde216180aa73bfc/pandas-2.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:f925f1ef673b4bd0271b1809b72b3270384f2b7d9d14a189b12b7fc02574d575", size = 12141356 },
+    { url = "https://files.pythonhosted.org/packages/9d/a2/9b903e5962134497ac4f8a96f862ee3081cb2506f69f8e4778ce3d9c9d82/pandas-2.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78ad363ddb873a631e92a3c063ade1ecfb34cae71e9a2be6ad100f875ac1042", size = 11474674 },
+    { url = "https://files.pythonhosted.org/packages/81/3a/3806d041bce032f8de44380f866059437fb79e36d6b22c82c187e65f765b/pandas-2.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:951805d146922aed8357e4cc5671b8b0b9be1027f0619cea132a9f3f65f2f09c", size = 11439876 },
+    { url = "https://files.pythonhosted.org/packages/15/aa/3fc3181d12b95da71f5c2537c3e3b3af6ab3a8c392ab41ebb766e0929bc6/pandas-2.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a881bc1309f3fce34696d07b00f13335c41f5f5a8770a33b09ebe23261cfc67", size = 11966182 },
+    { url = "https://files.pythonhosted.org/packages/37/e7/e12f2d9b0a2c4a2cc86e2aabff7ccfd24f03e597d770abfa2acd313ee46b/pandas-2.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e1991bbb96f4050b09b5f811253c4f3cf05ee89a589379aa36cd623f21a31d6f", size = 12547686 },
+    { url = "https://files.pythonhosted.org/packages/39/c2/646d2e93e0af70f4e5359d870a63584dacbc324b54d73e6b3267920ff117/pandas-2.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:bb3be958022198531eb7ec2008cfc78c5b1eed51af8600c6c5d9160d89d8d249", size = 13231847 },
+    { url = "https://files.pythonhosted.org/packages/38/86/d786690bd1d666d3369355a173b32a4ab7a83053cbb2d6a24ceeedb31262/pandas-2.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9efc0acbbffb5236fbdf0409c04edce96bec4bdaa649d49985427bd1ec73e085", size = 11552206 },
+    { url = "https://files.pythonhosted.org/packages/9c/2f/99f581c1c5b013fcfcbf00a48f5464fb0105da99ea5839af955e045ae3ab/pandas-2.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:75651c14fde635e680496148a8526b328e09fe0572d9ae9b638648c46a544ba3", size = 10796831 },
+    { url = "https://files.pythonhosted.org/packages/5c/be/3ee7f424367e0f9e2daee93a3145a18b703fbf733ba56e1cf914af4b40d1/pandas-2.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf5be867a0541a9fb47a4be0c5790a4bccd5b77b92f0a59eeec9375fafc2aa14", size = 11736943 },
+    { url = "https://files.pythonhosted.org/packages/83/95/81c7bb8f1aefecd948f80464177a7d9a1c5e205c5a1e279984fdacbac9de/pandas-2.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84141f722d45d0c2a89544dd29d35b3abfc13d2250ed7e68394eda7564bd6324", size = 12366679 },
+    { url = "https://files.pythonhosted.org/packages/d5/7a/54cf52fb454408317136d683a736bb597864db74977efee05e63af0a7d38/pandas-2.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:f95a2aef32614ed86216d3c450ab12a4e82084e8102e355707a1d96e33d51c34", size = 12924072 },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/25018e431257f8a42c173080f9da7c592508269def54af4a76ccd1c14420/pandas-2.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e0f51973ba93a9f97185049326d75b942b9aeb472bec616a129806facb129ebb", size = 13696374 },
+    { url = "https://files.pythonhosted.org/packages/db/84/5ffd2c447c02db56326f5c19a235a747fae727e4842cc20e1ddd28f990f6/pandas-2.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:b198687ca9c8529662213538a9bb1e60fa0bf0f6af89292eb68fea28743fcd5a", size = 11104735 },
+]
+
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -774,6 +1023,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5b/3a/c44a76c6bb5e9e896d9707fb1c704a31a0136950dec9514373ced0684d56/pytest_watcher-0.4.3-py3-none-any.whl", hash = "sha256:d59b1e1396f33a65ea4949b713d6884637755d641646960056a90b267c3460f9", size = 11852 },
 ]
 
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
+[[package]]
+name = "pytz"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 },
+]
+
 [[package]]
 name = "pyyaml"
 version = "6.0.2"
@@ -879,6 +1149,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/95/3a/2e8704d19f376c799748ff9cb041225c1d59f3e7711bc5596c8cfdc24925/ruff-0.11.10-py3-none-win_arm64.whl", hash = "sha256:ef69637b35fb8b210743926778d0e45e1bffa850a7c61e428c6b971549b5f5d1", size = 10765278 },
 ]
 
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
+]
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"
@@ -970,6 +1249,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 },
 ]
 
+[[package]]
+name = "tzdata"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 },
+]
+
 [[package]]
 name = "urllib3"
 version = "2.4.0"

libs/cli/examples/graphs/storm.py

@@ -22,10 +22,10 @@ from langgraph.graph import END, StateGraph
 from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
-fast_llm = ChatOpenAI(model="gpt-3.5-turbo")
+fast_llm = ChatOpenAI(model="gpt-4o-mini")
 # Uncomment for a Fireworks model
 # fast_llm = ChatFireworks(model="accounts/fireworks/models/firefunction-v1", max_tokens=32_000)
-long_context_llm = ChatOpenAI(model="gpt-4-turbo-preview")
+long_context_llm = ChatOpenAI(model="gpt-4o")
 
 
 direct_gen_outline_prompt = ChatPromptTemplate.from_messages(
@@ -144,7 +144,7 @@ gen_perspectives_prompt = ChatPromptTemplate.from_messages(
 )
 
 gen_perspectives_chain = gen_perspectives_prompt | ChatOpenAI(
-    model="gpt-3.5-turbo"
+    model="gpt-4o-mini"
 ).with_structured_output(Perspectives)
 
 
@@ -270,7 +270,7 @@ gen_queries_prompt = ChatPromptTemplate.from_messages(
     ]
 )
 gen_queries_chain = gen_queries_prompt | ChatOpenAI(
-    model="gpt-3.5-turbo"
+    model="gpt-4o-mini"
 ).with_structured_output(Queries, include_raw=True)
 
 

libs/cli/langgraph_cli/cli.py

@@ -318,10 +318,8 @@ def _build(
     )
     # add additional_contexts
     if additional_contexts:
-        additional_contexts_str = ",".join(
-            f"{k}={v}" for k, v in additional_contexts.items()
-        )
-        args.extend(["--build-context", additional_contexts_str])
+        for k, v in additional_contexts.items():
+            args.extend(["--build-context", f"{k}={v}"])
     # run docker build
     runner.run(
         subp_exec(

libs/cli/langgraph_cli/config.py

@@ -1,6 +1,7 @@
 import json
 import os
 import pathlib
+import re
 import textwrap
 from collections import Counter
 from typing import Any, Literal, NamedTuple, Optional, TypedDict, Union
@@ -382,6 +383,14 @@ class Config(TypedDict, total=False):
     Only relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.
     """
 
+    pip_installer: Optional[str]
+    """Optional. Python package installer to use ('auto', 'pip', 'uv').
+    
+    - 'auto' (default): Use uv for supported base images, otherwise pip
+    - 'pip': Force use of pip regardless of base image support
+    - 'uv': Force use of uv (will fail if base image doesn't support it)
+    """
+
     dockerfile_lines: list[str]
     """Optional. Additional Docker instructions that will be appended to your base Dockerfile.
     
@@ -461,7 +470,7 @@ class Config(TypedDict, total=False):
 PIP_CLEANUP_LINES = """# -- Ensure user deps didn't inadvertently overwrite langgraph-api
 RUN mkdir -p /api/langgraph_api /api/langgraph_runtime /api/langgraph_license && \
     touch /api/langgraph_api/__init__.py /api/langgraph_runtime/__init__.py /api/langgraph_license/__init__.py
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir --no-deps -e /api
+RUN PYTHONDONTWRITEBYTECODE=1 {install_cmd} --no-cache-dir --no-deps -e /api
 # -- End of ensuring user deps didn't inadvertently overwrite langgraph-api --
 # -- Removing pip from the final image ~<:===~~~ --
 RUN pip uninstall -y pip setuptools wheel && \
@@ -470,6 +479,7 @@ RUN pip uninstall -y pip setuptools wheel && \
 # pip removal for wolfi
 RUN rm -rf /usr/lib/python*/site-packages/pip* /usr/lib/python*/site-packages/setuptools* /usr/lib/python*/site-packages/wheel* && \
     find /usr/bin -name "pip*" -delete || true
+{uv_removal}
 # -- End of pip removal --"""
 
 
@@ -534,6 +544,7 @@ def validate_config(config: Config) -> Config:
         "node_version": node_version,
         "python_version": python_version,
         "pip_config_file": config.get("pip_config_file"),
+        "pip_installer": config.get("pip_installer", "auto"),
         "_INTERNAL_docker_tag": config.get("_INTERNAL_docker_tag"),
         "base_image": config.get("base_image"),
         "image_distro": image_distro,
@@ -598,6 +609,13 @@ def validate_config(config: Config) -> Config:
                 "Must be either 'debian' or 'wolfi'."
             )
 
+    if pip_installer := config.get("pip_installer"):
+        if pip_installer not in ["auto", "pip", "uv"]:
+            raise click.UsageError(
+                f"Invalid pip_installer: '{pip_installer}'. "
+                "Must be 'auto', 'pip', or 'uv'."
+            )
+
     # Validate auth config
     if auth_conf := config.get("auth"):
         if "path" in auth_conf:
@@ -1089,16 +1107,47 @@ def _get_node_pm_install_cmd(config_path: pathlib.Path, config: Config) -> str:
     return install_cmd
 
 
+semver_pattern = re.compile(r":(\d+(?:\.\d+)?(?:\.\d+)?)(?:-|$)")
+
+
+def _image_supports_uv(base_image: str) -> bool:
+    if base_image == "langchain/langgraph-trial":
+        return False
+    match = semver_pattern.search(base_image)
+    if not match:
+        # Default image (langchain/langgraph-api) supports it.
+        return True
+
+    version_str = match.group(1)
+    version = tuple(map(int, version_str.split(".")))
+    min_uv = (0, 2, 47)
+    return version >= min_uv
+
+
 def python_config_to_docker(
     config_path: pathlib.Path,
     config: Config,
     base_image: str,
 ) -> tuple[str, dict[str, str]]:
     """Generate a Dockerfile from the configuration."""
+    pip_installer = config.get("pip_installer", "auto")
+
+    if pip_installer == "uv":
+        install_cmd = "uv pip install --system"
+        uv_removal = "RUN uv pip uninstall --system pip setuptools wheel && rm /usr/bin/uv /usr/bin/uvx"
+    elif pip_installer == "pip":
+        install_cmd = "pip install"
+        uv_removal = ""
+    else:
+        if _image_supports_uv(base_image):
+            install_cmd = "uv pip install --system"
+            uv_removal = "RUN uv pip uninstall --system pip setuptools wheel && rm /usr/bin/uv /usr/bin/uvx"
+        else:
+            install_cmd = "pip install"
+            uv_removal = ""
+
     # configure pip
-    pip_install = (
-        "PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt"
-    )
+    pip_install = f"PYTHONDONTWRITEBYTECODE=1 {install_cmd} --no-cache-dir -c /api/constraints.txt"
     if config.get("pip_config_file"):
         pip_install = f"PIP_CONFIG_FILE=/pipconfig.txt {pip_install}"
     pip_config_file_str = (
@@ -1151,7 +1200,10 @@ RUN set -ex && \\
                 'name = "{fullpath.name}"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_{fullpath.name}/pyproject.toml; \\
     done
 # -- End of non-package dependency {fullpath.name} --"""
@@ -1240,7 +1292,8 @@ ADD {relpath} /deps/{name}
         "",
         js_inst_str,
         "",
-        PIP_CLEANUP_LINES,  # Add pip cleanup after all installations are complete
+        # Add pip cleanup after all installations are complete
+        PIP_CLEANUP_LINES.format(install_cmd=install_cmd, uv_removal=uv_removal),
         "",
         f"WORKDIR {local_deps.working_dir}" if local_deps.working_dir else "",
     ]

libs/cli/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-cli"
-version = "0.2.11"
+version = "0.3.3"
 description = "CLI for interacting with LangGraph API"
 authors = []
 requires-python = ">=3.9"

libs/cli/schemas/schema.json

@@ -134,6 +134,17 @@
               ],
               "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
             },
+            "pip_installer": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Python package installer to use ('auto', 'pip', 'uv').\n\n"
+            },
             "store": {
               "anyOf": [
                 {
@@ -287,6 +298,17 @@
               ],
               "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
             },
+            "pip_installer": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Python package installer to use ('auto', 'pip', 'uv').\n\n"
+            },
             "store": {
               "anyOf": [
                 {

libs/cli/schemas/schema.v0.json

@@ -134,6 +134,17 @@
               ],
               "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
             },
+            "pip_installer": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Python package installer to use ('auto', 'pip', 'uv').\n\n"
+            },
             "store": {
               "anyOf": [
                 {
@@ -287,6 +298,17 @@
               ],
               "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
             },
+            "pip_installer": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Python package installer to use ('auto', 'pip', 'uv').\n\n"
+            },
             "store": {
               "anyOf": [
                 {

libs/cli/tests/unit_tests/cli/test_cli.py

@@ -14,6 +14,10 @@ from langgraph_cli.config import PIP_CLEANUP_LINES, Config, validate_config
 from langgraph_cli.docker import DEFAULT_POSTGRES_URI, DockerCapabilities, Version
 from langgraph_cli.util import clean_empty_lines
 
+FORMATTED_CLEANUP_LINES = PIP_CLEANUP_LINES.format(
+    install_cmd="uv pip install --system",
+    uv_removal="RUN uv pip uninstall --system pip setuptools wheel && rm /usr/bin/uv /usr/bin/uvx",
+)
 DEFAULT_DOCKER_CAPABILITIES = DockerCapabilities(
     version_docker=Version(26, 1, 1),
     version_compose=Version(2, 27, 0),
@@ -22,12 +26,14 @@ DEFAULT_DOCKER_CAPABILITIES = DockerCapabilities(
 
 
 @contextmanager
-def temporary_config_folder(config_content: dict):
+def temporary_config_folder(config_content: dict, levels: int = 0):
     # Create a temporary directory
     temp_dir = tempfile.mkdtemp()
     try:
         # Define the path for the config.json file
-        config_path = Path(temp_dir) / "config.json"
+        config_path = Path(temp_dir) / f"{'a/' * levels}config.json"
+        # Ensure the parent directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
 
         # Write the provided dictionary content to config.json
         with open(config_path, "w", encoding="utf-8") as config_file:
@@ -142,10 +148,10 @@ services:
                 COPY --from=cli_1 . /deps/cli_1
                 # -- End of local package ../../.. --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/cli
         
         develop:
@@ -532,3 +538,38 @@ def test_build_command_shows_wolfi_warning() -> None:
         assert "Wolfi Linux" in result.output
         assert "image_distro" in result.output
         assert "wolfi" in result.output
+
+
+def test_build_generate_proper_build_context():
+    runner = CliRunner()
+    config_content = {
+        "python_version": "3.11",
+        "graphs": {"agent": "agent.py:graph"},
+        "dependencies": [".", "../../..", "../.."],
+        "image_distro": "wolfi",
+    }
+
+    with temporary_config_folder(config_content, levels=3) as temp_dir:
+        agent_path = temp_dir / "agent.py"
+        agent_path.touch()
+
+        # Mock docker command since we don't want to actually build
+        with runner.isolated_filesystem():
+            result = runner.invoke(
+                cli,
+                [
+                    "build",
+                    "--tag",
+                    "test-image",
+                    "--config",
+                    str(temp_dir / "config.json"),
+                ],
+                catch_exceptions=True,
+            )
+
+        build_context_pattern = re.compile(r"--build-context\s+(\w+)=([^\s]+)")
+
+        build_contexts = re.findall(build_context_pattern, result.output)
+        assert (
+            len(build_contexts) == 2
+        ), f"Expected 2 build contexts, but found {len(build_contexts)}"

libs/cli/tests/unit_tests/test_config.py

@@ -1,3 +1,4 @@
+import copy
 import json
 import os
 import pathlib
@@ -17,6 +18,11 @@ from langgraph_cli.config import (
 )
 from langgraph_cli.util import clean_empty_lines
 
+FORMATTED_CLEANUP_LINES = PIP_CLEANUP_LINES.format(
+    install_cmd="uv pip install --system",
+    uv_removal="RUN uv pip uninstall --system pip setuptools wheel && rm /usr/bin/uv /usr/bin/uvx",
+)
+
 PATH_TO_CONFIG = pathlib.Path(__file__).parent / "test_config.json"
 
 
@@ -35,6 +41,7 @@ def test_validate_config():
         "python_version": "3.11",
         "node_version": None,
         "pip_config_file": None,
+        "pip_installer": "auto",
         "image_distro": "debian",
         "dockerfile_lines": [],
         "env": {},
@@ -56,6 +63,7 @@ def test_validate_config():
         "python_version": "3.12",
         "node_version": None,
         "pip_config_file": "pipconfig.txt",
+        "pip_installer": "auto",
         "image_distro": "debian",
         "dockerfile_lines": ["ARG meow"],
         "dependencies": [".", "langchain"],
@@ -211,6 +219,74 @@ def test_validate_config_image_distro():
     assert config["image_distro"] == "debian"
 
 
+def test_validate_config_pip_installer():
+    """Test validation of pip_installer field."""
+    # Valid pip_installer values should work
+    config = validate_config(
+        {
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "auto",
+        }
+    )
+    assert config["pip_installer"] == "auto"
+
+    config = validate_config(
+        {
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "pip",
+        }
+    )
+    assert config["pip_installer"] == "pip"
+
+    config = validate_config(
+        {
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+            "pip_installer": "uv",
+        }
+    )
+    assert config["pip_installer"] == "uv"
+
+    # Missing pip_installer should default to "auto"
+    config = validate_config(
+        {
+            "python_version": "3.11",
+            "dependencies": ["."],
+            "graphs": {"agent": "./agent.py:graph"},
+        }
+    )
+    assert config["pip_installer"] == "auto"
+
+    # Invalid pip_installer values should raise error
+    with pytest.raises(click.UsageError) as exc_info:
+        validate_config(
+            {
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "pip_installer": "conda",
+            }
+        )
+    assert "Invalid pip_installer: 'conda'" in str(exc_info.value)
+    assert "Must be 'auto', 'pip', or 'uv'" in str(exc_info.value)
+
+    with pytest.raises(click.UsageError) as exc_info:
+        validate_config(
+            {
+                "python_version": "3.11",
+                "dependencies": ["."],
+                "graphs": {"agent": "./agent.py:graph"},
+                "pip_installer": "invalid",
+            }
+        )
+    assert "Invalid pip_installer: 'invalid'" in str(exc_info.value)
+
+
 def test_validate_config_file():
     with tempfile.TemporaryDirectory() as tmpdir:
         tmpdir_path = pathlib.Path(tmpdir)
@@ -345,7 +421,7 @@ def test_config_to_docker_simple():
 FROM langchain/langgraph-api:3.11
 # -- Installing local requirements --
 COPY --from=__outer_requirements.txt requirements.txt /deps/__outer_graphs_reqs_a/graphs_reqs_a/requirements.txt
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -r /deps/__outer_graphs_reqs_a/graphs_reqs_a/requirements.txt
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -r /deps/__outer_graphs_reqs_a/graphs_reqs_a/requirements.txt
 # -- End of local requirements install --
 # -- Adding local package ../../examples --
 COPY --from=examples . /deps/examples
@@ -357,7 +433,10 @@ RUN set -ex && \\
                 'name = "unit_tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency unit_tests --
@@ -368,16 +447,19 @@ RUN set -ex && \\
                 'name = "graphs_reqs_a"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_graphs_reqs_a/pyproject.toml; \\
     done
 # -- End of non-package dependency graphs_reqs_a --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGGRAPH_HTTP='{{"app": "/deps/examples/my_app.py:app"}}'
 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{PIP_CLEANUP_LINES}
+{FORMATTED_CLEANUP_LINES}
 WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
     assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
@@ -407,7 +489,10 @@ RUN set -ex && \\
                 'name = "unit_tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency unit_tests --
@@ -418,16 +503,19 @@ RUN set -ex && \\
                 'name = "tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}'
 """
-        + PIP_CLEANUP_LINES
+        + FORMATTED_CLEANUP_LINES
         + """
 WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
@@ -462,16 +550,19 @@ RUN set -ex && \\
                 'name = "unit_tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}'
 """
-        + PIP_CLEANUP_LINES
+        + FORMATTED_CLEANUP_LINES
         + """
 WORKDIR /deps/__outer_unit_tests/unit_tests\
 """
@@ -521,15 +612,18 @@ RUN set -ex && \\
                 'name = "graphs"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_graphs/pyproject.toml; \\
     done
 # -- End of non-package dependency graphs --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_graphs/src/agent.py:graph"}}'
-{PIP_CLEANUP_LINES}\
+{FORMATTED_CLEANUP_LINES}\
 """
     assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
     assert additional_contexts == {}
@@ -562,11 +656,11 @@ dependencies = ["langchain"]"""
 ADD . /deps/unit_tests
 # -- End of local package . --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{"agent": "/deps/unit_tests/graphs/agent.py:graph"}'
 """
-        + PIP_CLEANUP_LINES
+        + FORMATTED_CLEANUP_LINES
         + "\n"
         + "WORKDIR /deps/unit_tests"
         ""
@@ -594,7 +688,7 @@ def test_config_to_docker_end_to_end():
 ARG meow
 ARG foo
 ADD pipconfig.txt /pipconfig.txt
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt langchain langchain_openai
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt langchain langchain_openai
 # -- Adding non-package dependency graphs --
 ADD ./graphs/ /deps/__outer_graphs/src
 RUN set -ex && \\
@@ -602,15 +696,18 @@ RUN set -ex && \\
                 'name = "graphs"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_graphs/pyproject.toml; \\
     done
 # -- End of non-package dependency graphs --
 # -- Installing all local dependencies --
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_graphs/src/agent.py:graph"}}'
-{PIP_CLEANUP_LINES}"""
+{FORMATTED_CLEANUP_LINES}"""
     assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
     assert additional_contexts == {}
 
@@ -705,12 +802,15 @@ RUN set -ex && \\
                 'name = "unit_tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGGRAPH_UI='{{"agent": "./graphs/agent.ui.jsx"}}'
 ENV LANGGRAPH_UI_CONFIG='{{"shared": ["nuqs"]}}'
@@ -719,7 +819,7 @@ ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:g
 ENV NODE_VERSION=20
 RUN cd /deps/__outer_unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
 # -- End of JS dependencies install --
-{PIP_CLEANUP_LINES}
+{FORMATTED_CLEANUP_LINES}
 WORKDIR /deps/__outer_unit_tests/unit_tests"""
 
     assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
@@ -748,29 +848,87 @@ RUN set -ex && \\
                 'name = "unit_tests"' \\
                 'version = "0.1"' \\
                 '[tool.setuptools.package-data]' \\
-                '"*" = ["**/*"]'; do \\
+                '"*" = ["**/*"]' \\
+                '[build-system]' \\
+                'requires = ["setuptools>=61"]' \\
+                'build-backend = "setuptools.build_meta"'; do \\
         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
     done
 # -- End of non-package dependency unit_tests --
 # -- Installing all local dependencies --
-RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
 # -- End of local dependencies install --
 ENV LANGSERVE_GRAPHS='{{"python": "/deps/__outer_unit_tests/unit_tests/multiplatform/python.py:graph", "js": "/deps/__outer_unit_tests/unit_tests/multiplatform/js.mts:graph"}}'
 # -- Installing JS dependencies --
 ENV NODE_VERSION=22
 RUN cd /deps/__outer_unit_tests/unit_tests && npm i && tsx /api/langgraph_api/js/build.mts
 # -- End of JS dependencies install --
-{PIP_CLEANUP_LINES}
+{FORMATTED_CLEANUP_LINES}
 WORKDIR /deps/__outer_unit_tests/unit_tests"""
 
     assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
     assert additional_contexts == {}
 
 
+def test_config_to_docker_pip_installer():
+    """Test that pip_installer setting affects the generated Dockerfile."""
+    graphs = {"agent": "./graphs/agent.py:graph"}
+    base_config = {
+        "python_version": "3.11",
+        "dependencies": ["."],
+        "graphs": graphs,
+    }
+
+    # Test default (auto) behavior with UV-supporting image
+    config_auto = validate_config(
+        {**copy.deepcopy(base_config), "pip_installer": "auto"}
+    )
+    docker_auto, _ = config_to_docker(
+        PATH_TO_CONFIG, config_auto, "langchain/langgraph-api:0.2.47"
+    )
+    assert "uv pip install --system" in docker_auto
+    assert "rm /usr/bin/uv /usr/bin/uvx" in docker_auto
+
+    # Test explicit pip setting
+    config_pip = validate_config({**copy.deepcopy(base_config), "pip_installer": "pip"})
+    docker_pip, _ = config_to_docker(
+        PATH_TO_CONFIG, config_pip, "langchain/langgraph-api:0.2.47"
+    )
+    assert "uv pip install --system" not in docker_pip
+    assert "pip install" in docker_pip
+    assert "rm /usr/bin/uv" not in docker_pip
+
+    # Test explicit uv setting
+    config_uv = validate_config({**copy.deepcopy(base_config), "pip_installer": "uv"})
+    docker_uv, _ = config_to_docker(
+        PATH_TO_CONFIG, config_uv, "langchain/langgraph-api:0.2.47"
+    )
+    assert "uv pip install --system" in docker_uv
+    assert "rm /usr/bin/uv /usr/bin/uvx" in docker_uv
+
+    # Test auto behavior with older image (should use pip)
+    config_auto_old = validate_config(
+        {**copy.deepcopy(base_config), "pip_installer": "auto"}
+    )
+    docker_auto_old, _ = config_to_docker(
+        PATH_TO_CONFIG, config_auto_old, "langchain/langgraph-api:0.2.46"
+    )
+    assert "uv pip install --system" not in docker_auto_old
+    assert "pip install" in docker_auto_old
+    assert "rm /usr/bin/uv" not in docker_auto_old
+
+    # Test that missing pip_installer defaults to auto behavior
+    config_default = validate_config(copy.deepcopy(base_config))
+    docker_default, _ = config_to_docker(
+        PATH_TO_CONFIG, config_default, "langchain/langgraph-api:0.2.47"
+    )
+    assert "uv pip install --system" in docker_default
+
+
 # config_to_compose
 def test_config_to_compose_simple_config():
     graphs = {"agent": "./agent.py:graph"}
-    # Create a properly indented version of PIP_CLEANUP_LINES for compose files
+    # Create a properly indented version of FORMATTED_CLEANUP_LINES for compose files
     expected_compose_stdin = f"""
         pull_policy: build
         build:
@@ -784,15 +942,18 @@ def test_config_to_compose_simple_config():
                                 'name = "unit_tests"' \\
                                 'version = "0.1"' \\
                                 '[tool.setuptools.package-data]' \\
-                                '"*" = ["**/*"]'; do \\
+                                '"*" = ["**/*"]' \\
+                                '[build-system]' \\
+                                'requires = ["setuptools>=61"]' \\
+                                'build-backend = "setuptools.build_meta"'; do \\
                         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                     done
                 # -- End of non-package dependency unit_tests --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/__outer_unit_tests/unit_tests
         """
     actual_compose_stdin = config_to_compose(
@@ -822,15 +983,18 @@ def test_config_to_compose_env_vars():
                                 'name = "unit_tests"' \\
                                 'version = "0.1"' \\
                                 '[tool.setuptools.package-data]' \\
-                                '"*" = ["**/*"]'; do \\
+                                '"*" = ["**/*"]' \\
+                                '[build-system]' \\
+                                'requires = ["setuptools>=61"]' \\
+                                'build-backend = "setuptools.build_meta"'; do \\
                         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                     done
                 # -- End of non-package dependency unit_tests --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/__outer_unit_tests/unit_tests
         """
     openai_api_key = "key"
@@ -864,15 +1028,18 @@ def test_config_to_compose_env_file():
                                 'name = "unit_tests"' \\
                                 'version = "0.1"' \\
                                 '[tool.setuptools.package-data]' \\
-                                '"*" = ["**/*"]'; do \\
+                                '"*" = ["**/*"]' \\
+                                '[build-system]' \\
+                                'requires = ["setuptools>=61"]' \\
+                                'build-backend = "setuptools.build_meta"'; do \\
                         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                     done
                 # -- End of non-package dependency unit_tests --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/__outer_unit_tests/unit_tests
         """
     actual_compose_stdin = config_to_compose(
@@ -899,15 +1066,18 @@ def test_config_to_compose_watch():
                                 'name = "unit_tests"' \\
                                 'version = "0.1"' \\
                                 '[tool.setuptools.package-data]' \\
-                                '"*" = ["**/*"]'; do \\
+                                '"*" = ["**/*"]' \\
+                                '[build-system]' \\
+                                'requires = ["setuptools>=61"]' \\
+                                'build-backend = "setuptools.build_meta"'; do \\
                         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                     done
                 # -- End of non-package dependency unit_tests --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/__outer_unit_tests/unit_tests
         
         develop:
@@ -943,15 +1113,18 @@ def test_config_to_compose_end_to_end():
                                 'name = "unit_tests"' \\
                                 'version = "0.1"' \\
                                 '[tool.setuptools.package-data]' \\
-                                '"*" = ["**/*"]'; do \\
+                                '"*" = ["**/*"]' \\
+                                '[build-system]' \\
+                                'requires = ["setuptools>=61"]' \\
+                                'build-backend = "setuptools.build_meta"'; do \\
                         echo "$line" >> /deps/__outer_unit_tests/pyproject.toml; \\
                     done
                 # -- End of non-package dependency unit_tests --
                 # -- Installing all local dependencies --
-                RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
+                RUN PYTHONDONTWRITEBYTECODE=1 uv pip install --system --no-cache-dir -c /api/constraints.txt -e /deps/*
                 # -- End of local dependencies install --
                 ENV LANGSERVE_GRAPHS='{{"agent": "/deps/__outer_unit_tests/unit_tests/agent.py:graph"}}'
-{textwrap.indent(textwrap.dedent(PIP_CLEANUP_LINES), "                ")}
+{textwrap.indent(textwrap.dedent(FORMATTED_CLEANUP_LINES), "                ")}
                 WORKDIR /deps/__outer_unit_tests/unit_tests
         
         develop:

libs/cli/uv.lock

@@ -501,7 +501,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-cli"
-version = "0.2.11"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

libs/langgraph/README.md

@@ -12,7 +12,6 @@
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
-[![GitMCP](https://img.shields.io/endpoint?url=https://gitmcp.io/badge/langchain-ai/langgraph)](https://gitmcp.io/langchain-ai/langgraph)
 
 Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.
 

libs/langgraph/bench/fanout_to_subgraph.py

@@ -37,7 +37,7 @@ def fanout_to_subgraph() -> StateGraph:
         return END if state["jokes"][0].endswith(" a" * 10) else "bump"
 
     # subgraph
-    subgraph = StateGraph(JokeState, input=JokeInput, output=JokeOutput)
+    subgraph = StateGraph(JokeState, input_schema=JokeInput, output_schema=JokeOutput)
     subgraph.add_node("edit", edit)
     subgraph.add_node("generate", generate)
     subgraph.add_node("bump", bump)
@@ -87,7 +87,7 @@ def fanout_to_subgraph_sync() -> StateGraph:
         return END if state["jokes"][0].endswith(" a" * 10) else "bump"
 
     # subgraph
-    subgraph = StateGraph(JokeState, input=JokeInput, output=JokeOutput)
+    subgraph = StateGraph(JokeState, input_schema=JokeInput, output_schema=JokeOutput)
     subgraph.add_node("edit", edit)
     subgraph.add_node("generate", generate)
     subgraph.add_node("bump", bump)

libs/langgraph/langgraph/_typing.py

@@ -0,0 +1,54 @@
+"""Private typing utilities for LangGraph."""
+
+from __future__ import annotations
+
+from dataclasses import Field
+from typing import Any, ClassVar, Protocol, Union
+
+from pydantic import BaseModel
+from typing_extensions import TypeAlias, TypedDict
+
+
+class TypedDictLikeV1(Protocol):
+    """Protocol to represent types that behave like TypedDicts
+
+    Version 1: using `ClassVar` for keys."""
+
+    __required_keys__: ClassVar[frozenset[str]]
+    __optional_keys__: ClassVar[frozenset[str]]
+
+
+class TypedDictLikeV2(Protocol):
+    """Protocol to represent types that behave like TypedDicts
+
+    Version 2: not using `ClassVar` for keys."""
+
+    __required_keys__: frozenset[str]
+    __optional_keys__: frozenset[str]
+
+
+class DataclassLike(Protocol):
+    """Protocol to represent types that behave like dataclasses.
+
+    Inspired by the private _DataclassT from dataclasses that uses a similar protocol as a bound."""
+
+    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
+
+
+StateLike: TypeAlias = Union[TypedDictLikeV1, TypedDictLikeV2, DataclassLike, BaseModel]
+"""Type alias for state-like types.
+
+It can either be a `TypedDict`, `dataclass`, or Pydantic `BaseModel`.
+Note: we cannot use either `TypedDict` or `dataclass` directly due to limitations in type checking.
+"""
+
+
+class Unset:
+    """A sentinel value to represent an unset type."""
+
+
+UNSET: Unset = Unset()
+
+
+class DeprecatedKwargs(TypedDict):
+    """TypedDict to use for extra keyword arguments, enabling type checking warnings for deprecated arguments."""

libs/langgraph/langgraph/channels/topic.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Iterator, Sequence
 from typing import Any, Generic, Union
 
@@ -8,7 +10,7 @@ from langgraph.constants import MISSING
 from langgraph.errors import EmptyChannelError
 
 
-def flatten(values: Sequence[Union[Value, list[Value]]]) -> Iterator[Value]:
+def flatten(values: Sequence[Value | list[Value]]) -> Iterator[Value]:
     for value in values:
         if isinstance(value, list):
             yield from value
@@ -70,7 +72,7 @@ class Topic(
                 empty.values = checkpoint
         return empty
 
-    def update(self, values: Sequence[Union[Value, list[Value]]]) -> bool:
+    def update(self, values: Sequence[Value | list[Value]]) -> bool:
         updated = False
         if not self.accumulate:
             updated = bool(self.values)

libs/langgraph/langgraph/constants.py

@@ -39,8 +39,6 @@ ERROR = sys.intern("__error__")
 # for errors raised by nodes
 NO_WRITES = sys.intern("__no_writes__")
 # marker to signal node didn't write anything
-SCHEDULED = sys.intern("__scheduled__")
-# marker to signal node was scheduled (in distributed mode)
 TASKS = sys.intern("__pregel_tasks")
 # for Send objects returned by nodes/edges, corresponds to PUSH below
 RETURN = sys.intern("__return__")
@@ -71,13 +69,6 @@ CONFIG_KEY_RESUMING = sys.intern("__pregel_resuming")
 # holds a boolean indicating if subgraphs should resume from a previous checkpoint
 CONFIG_KEY_TASK_ID = sys.intern("__pregel_task_id")
 # holds the task ID for the current task
-CONFIG_KEY_DEDUPE_TASKS = sys.intern("__pregel_dedupe_tasks")
-# holds a boolean indicating if tasks should be deduplicated (for distributed mode)
-CONFIG_KEY_ENSURE_LATEST = sys.intern("__pregel_ensure_latest")
-# holds a boolean indicating whether to assert the requested checkpoint is the latest
-# (for distributed mode)
-CONFIG_KEY_DELEGATE = sys.intern("__pregel_delegate")
-# holds a boolean indicating whether to delegate subgraphs (for distributed mode)
 CONFIG_KEY_THREAD_ID = sys.intern("thread_id")
 # holds the thread ID for the current invocation
 CONFIG_KEY_CHECKPOINT_MAP = sys.intern("checkpoint_map")
@@ -121,7 +112,6 @@ RESERVED = {
     RESUME,
     ERROR,
     NO_WRITES,
-    SCHEDULED,
     # reserved config.configurable keys
     CONFIG_KEY_SEND,
     CONFIG_KEY_READ,
@@ -132,9 +122,6 @@ RESERVED = {
     CONFIG_KEY_CHECKPOINT_MAP,
     CONFIG_KEY_RESUMING,
     CONFIG_KEY_TASK_ID,
-    CONFIG_KEY_DEDUPE_TASKS,
-    CONFIG_KEY_ENSURE_LATEST,
-    CONFIG_KEY_DELEGATE,
     CONFIG_KEY_CHECKPOINT_MAP,
     CONFIG_KEY_CHECKPOINT_ID,
     CONFIG_KEY_CHECKPOINT_NS,

libs/langgraph/langgraph/errors.py

@@ -78,13 +78,6 @@ class NodeInterrupt(GraphInterrupt):
         super().__init__([Interrupt(value=value)])
 
 
-class GraphDelegate(GraphBubbleUp):
-    """Raised when a graph is delegated (for distributed mode)."""
-
-    def __init__(self, *args: dict[str, Any]) -> None:
-        super().__init__(*args)
-
-
 class ParentCommand(GraphBubbleUp):
     args: tuple[Command]
 
@@ -102,9 +95,3 @@ class TaskNotFound(Exception):
     """Raised when the executor is unable to find a task (for distributed mode)."""
 
     pass
-
-
-class CheckpointNotLatest(Exception):
-    """Raised when the checkpoint is not the latest version (for distributed mode)."""
-
-    pass

libs/langgraph/langgraph/func/__init__.py

@@ -1,21 +1,25 @@
+from __future__ import annotations
+
 import asyncio
 import concurrent.futures
 import functools
 import inspect
+import warnings
 from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass
 from typing import (
     Any,
     Callable,
     Generic,
-    Optional,
     TypeVar,
-    Union,
     get_args,
     get_origin,
     overload,
 )
 
+from typing_extensions import Unpack
+
+from langgraph._typing import UNSET, DeprecatedKwargs
 from langgraph.cache.base import BaseCache
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue
@@ -34,6 +38,7 @@ from langgraph.pregel.read import PregelNode
 from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
 from langgraph.store.base import BaseStore
 from langgraph.types import _DC_KWARGS, CachePolicy, RetryPolicy, StreamMode
+from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 
 class TaskFunction(Generic[P, T]):
@@ -41,9 +46,9 @@ class TaskFunction(Generic[P, T]):
         self,
         func: Callable[P, T],
         *,
-        retry: Optional[Sequence[RetryPolicy]] = (),
-        cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
-        name: Optional[str] = None,
+        retry_policy: Sequence[RetryPolicy],
+        cache_policy: CachePolicy[Callable[P, str | bytes]] | None = None,
+        name: str | None = None,
     ) -> None:
         if name is not None:
             if hasattr(func, "__func__"):
@@ -57,13 +62,17 @@ class TaskFunction(Generic[P, T]):
                 # handle regular functions / partials / callable classes, etc.
                 func.__name__ = name
         self.func = func
-        self.retry = retry
+        self.retry_policy = retry_policy
         self.cache_policy = cache_policy
         functools.update_wrapper(self, func)
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> SyncAsyncFuture[T]:
         return call(
-            self.func, retry=self.retry, cache_policy=self.cache_policy, *args, **kwargs
+            self.func,
+            retry_policy=self.retry_policy,
+            cache_policy=self.cache_policy,
+            *args,
+            **kwargs,
         )
 
     def clear_cache(self, cache: BaseCache) -> None:
@@ -82,34 +91,33 @@ class TaskFunction(Generic[P, T]):
 @overload
 def task(
     *,
-    name: Optional[str] = None,
-    retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-    cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
+    name: str | None = None,
+    retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+    cache_policy: CachePolicy[Callable[P, str | bytes]] | None = None,
+    **kwargs: Unpack[DeprecatedKwargs],
 ) -> Callable[
-    [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
+    [Callable[P, Awaitable[T]] | Callable[P, T]],
     TaskFunction[P, T],
 ]: ...
 
 
 @overload
 def task(
-    __func_or_none__: Union[Callable[P, Awaitable[T]], Callable[P, T]],
+    __func_or_none__: Callable[P, Awaitable[T]] | Callable[P, T],
 ) -> TaskFunction[P, T]: ...
 
 
 def task(
-    __func_or_none__: Optional[Union[Callable[P, Awaitable[T]], Callable[P, T]]] = None,
+    __func_or_none__: Callable[P, Awaitable[T]] | Callable[P, T] | None = None,
     *,
-    name: Optional[str] = None,
-    retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-    cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
-) -> Union[
-    Callable[
-        [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
-        TaskFunction[P, T],
-    ],
-    TaskFunction[P, T],
-]:
+    name: str | None = None,
+    retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+    cache_policy: CachePolicy[Callable[P, str | bytes]] | None = None,
+    **kwargs: Unpack[DeprecatedKwargs],
+) -> (
+    Callable[[Callable[P, Awaitable[T]] | Callable[P, T]], TaskFunction[P, T]]
+    | TaskFunction[P, T]
+):
     """Define a LangGraph task using the `task` decorator.
 
     !!! important "Requires python 3.11 or higher for async functions"
@@ -125,7 +133,9 @@ def task(
     - Calling the function produces a future. This makes it easy to parallelize tasks.
 
     Args:
-        retry: An optional retry policy to use for the task in case of a failure.
+        name: An optional name for the task. If not provided, the function name will be used.
+        retry_policy: An optional retry policy (or list of policies) to use for the task in case of a failure.
+        cache_policy: An optional cache policy to use for the task. This allows caching of the task results.
 
     Returns:
         A callable function when used as a decorator.
@@ -166,18 +176,27 @@ def task(
         await add_one.ainvoke([1, 2, 3])  # Returns [2, 3, 4]
         ```
     """
-    if isinstance(retry, RetryPolicy):
-        retry_policies: Optional[Sequence[RetryPolicy]] = (retry,)
-    else:
-        retry_policies = retry
+    if (retry := kwargs.get("retry", UNSET)) is not UNSET:
+        warnings.warn(
+            "`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
+            category=LangGraphDeprecatedSinceV10,
+        )
+        if retry_policy is None:
+            retry_policy = retry  # type: ignore[assignment]
+
+    retry_policies: Sequence[RetryPolicy] = (
+        ()
+        if retry_policy is None
+        else (retry_policy,)
+        if isinstance(retry_policy, RetryPolicy)
+        else retry_policy
+    )
 
     def decorator(
-        func: Union[Callable[P, Awaitable[T]], Callable[P, T]],
-    ) -> Union[
-        Callable[P, concurrent.futures.Future[T]], Callable[P, asyncio.Future[T]]
-    ]:
+        func: Callable[P, Awaitable[T]] | Callable[P, T],
+    ) -> Callable[P, concurrent.futures.Future[T]] | Callable[P, asyncio.Future[T]]:
         return TaskFunction(
-            func, retry=retry_policies, cache_policy=cache_policy, name=name
+            func, retry_policy=retry_policies, cache_policy=cache_policy, name=name
         )
 
     if __func_or_none__ is not None:
@@ -232,8 +251,11 @@ class entrypoint:
             its state across runs.
         store: A generalized key-value store. Some implementations may support
             semantic search capabilities through an optional `index` configuration.
+        cache: A cache to use for caching the results of the workflow.
         config_schema: Specifies the schema for the configuration object that will be
             passed to the workflow.
+        cache_policy: A cache policy to use for caching the results of the workflow.
+        retry_policy: A retry policy (or list of policies) to use for the workflow in case of a failure.
 
     Example: Using entrypoint and tasks
         ```python
@@ -349,19 +371,28 @@ class entrypoint:
 
     def __init__(
         self,
-        checkpointer: Optional[BaseCheckpointSaver] = None,
-        store: Optional[BaseStore] = None,
-        cache: Optional[BaseCache] = None,
-        config_schema: Optional[type[Any]] = None,
-        cache_policy: Optional[CachePolicy] = None,
-        retry: Union[RetryPolicy, Sequence[RetryPolicy]] = (),
+        checkpointer: BaseCheckpointSaver | None = None,
+        store: BaseStore | None = None,
+        cache: BaseCache | None = None,
+        config_schema: type[Any] | None = None,
+        cache_policy: CachePolicy | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        **kwargs: Unpack[DeprecatedKwargs],
     ) -> None:
         """Initialize the entrypoint decorator."""
+        if (retry := kwargs.get("retry", UNSET)) is not UNSET:
+            warnings.warn(
+                "`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
+                category=LangGraphDeprecatedSinceV10,
+            )
+            if retry_policy is None:
+                retry_policy = retry  # type: ignore[assignment]
+
         self.checkpointer = checkpointer
         self.store = store
         self.cache = cache
         self.cache_policy = cache_policy
-        self.retry = retry
+        self.retry_policy = retry_policy
         self.config_schema = config_schema
 
     @dataclass(**_DC_KWARGS)
@@ -468,7 +499,7 @@ class entrypoint:
                 func.__name__: PregelNode(
                     bound=bound,
                     triggers=[START],
-                    channels=[START],
+                    channels=START,
                     writers=[
                         ChannelWrite(
                             [
@@ -493,6 +524,6 @@ class entrypoint:
             store=self.store,
             cache=self.cache,
             cache_policy=self.cache_policy,
-            retry_policy=self.retry,
+            retry_policy=self.retry_policy or (),
             config_type=self.config_schema,
         )

libs/langgraph/langgraph/graph/branch.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Awaitable, Hashable, Sequence
 from inspect import (
     isfunction,
@@ -11,7 +13,6 @@ from typing import (
     Callable,
     Literal,
     NamedTuple,
-    Optional,
     Union,
     cast,
     get_args,
@@ -40,21 +41,18 @@ Writer = Callable[
 
 
 def _get_branch_path_input_schema(
-    path: Union[
-        Callable[..., Union[Hashable, list[Hashable]]],
-        Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
-        Runnable[Any, Union[Hashable, list[Hashable]]],
-    ],
-) -> Optional[type[Any]]:
+    path: Callable[..., Hashable | list[Hashable]]
+    | Callable[..., Awaitable[Hashable | list[Hashable]]]
+    | Runnable[Any, Hashable | list[Hashable]],
+) -> type[Any] | None:
     input = None
     # detect input schema annotation in the branch callable
     try:
-        callable_: Optional[
-            Union[
-                Callable[..., Union[Hashable, list[Hashable]]],
-                Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
-            ]
-        ] = None
+        callable_: (
+            Callable[..., Hashable | list[Hashable]]
+            | Callable[..., Awaitable[Hashable | list[Hashable]]]
+            | None
+        ) = None
         if isinstance(path, (RunnableCallable, RunnableLambda)):
             if isfunction(path.func) or ismethod(path.func):
                 callable_ = path.func
@@ -85,19 +83,19 @@ def _get_branch_path_input_schema(
 
 
 class Branch(NamedTuple):
-    path: Runnable[Any, Union[Hashable, list[Hashable]]]
-    ends: Optional[dict[Hashable, str]]
-    input_schema: Optional[type[Any]] = None
+    path: Runnable[Any, Hashable | list[Hashable]]
+    ends: dict[Hashable, str] | None
+    input_schema: type[Any] | None = None
 
     @classmethod
     def from_path(
         cls,
-        path: Runnable[Any, Union[Hashable, list[Hashable]]],
-        path_map: Optional[Union[dict[Hashable, str], list[str]]],
+        path: Runnable[Any, Hashable | list[Hashable]],
+        path_map: dict[Hashable, str] | list[str] | None,
         infer_schema: bool = False,
-    ) -> "Branch":
+    ) -> Branch:
         # coerce path_map to a dictionary
-        path_map_: Optional[dict[Hashable, str]] = None
+        path_map_: dict[Hashable, str] | None = None
         try:
             if isinstance(path_map, dict):
                 path_map_ = path_map.copy()
@@ -105,7 +103,7 @@ class Branch(NamedTuple):
                 path_map_ = {name: name for name in path_map}
             else:
                 # find func
-                func: Optional[Callable] = None
+                func: Callable | None = None
                 if isinstance(path, (RunnableCallable, RunnableLambda)):
                     func = path.func or path.afunc
                 if func is not None:
@@ -126,7 +124,7 @@ class Branch(NamedTuple):
     def run(
         self,
         writer: Writer,
-        reader: Optional[Callable[[RunnableConfig], Any]] = None,
+        reader: Callable[[RunnableConfig], Any] | None = None,
     ) -> RunnableCallable:
         return ChannelWrite.register_writer(
             RunnableCallable(
@@ -153,7 +151,7 @@ class Branch(NamedTuple):
         input: Any,
         config: RunnableConfig,
         *,
-        reader: Optional[Callable[[RunnableConfig], Any]],
+        reader: Callable[[RunnableConfig], Any] | None,
         writer: Writer,
     ) -> Runnable:
         if reader:
@@ -176,7 +174,7 @@ class Branch(NamedTuple):
         input: Any,
         config: RunnableConfig,
         *,
-        reader: Optional[Callable[[RunnableConfig], Any]],
+        reader: Callable[[RunnableConfig], Any] | None,
         writer: Writer,
     ) -> Runnable:
         if reader:
@@ -200,11 +198,11 @@ class Branch(NamedTuple):
         input: Any,
         result: Any,
         config: RunnableConfig,
-    ) -> Union[Runnable, Any]:
+    ) -> Runnable | Any:
         if not isinstance(result, (list, tuple)):
             result = [result]
         if self.ends:
-            destinations: Sequence[Union[Send, str]] = [
+            destinations: Sequence[Send | str] = [
                 r if isinstance(r, Send) else self.ends[r] for r in result
             ]
         else:

libs/langgraph/langgraph/graph/message.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import uuid
 import warnings
 from collections.abc import Sequence
@@ -7,7 +9,6 @@ from typing import (
     Any,
     Callable,
     Literal,
-    Optional,
     Union,
     cast,
 )
@@ -32,8 +33,8 @@ REMOVE_ALL_MESSAGES = "__remove_all__"
 
 def _add_messages_wrapper(func: Callable) -> Callable[[Messages, Messages], Messages]:
     def _add_messages(
-        left: Optional[Messages] = None, right: Optional[Messages] = None, **kwargs: Any
-    ) -> Union[Messages, Callable[[Messages, Messages], Messages]]:
+        left: Messages | None = None, right: Messages | None = None, **kwargs: Any
+    ) -> Messages | Callable[[Messages, Messages], Messages]:
         if left is not None and right is not None:
             return func(left, right, **kwargs)
         elif left is not None or right is not None:
@@ -54,7 +55,7 @@ def add_messages(
     left: Messages,
     right: Messages,
     *,
-    format: Optional[Literal["langchain-openai"]] = None,
+    format: Literal["langchain-openai"] | None = None,
 ) -> Messages:
     """Merges two lists of messages, updating existing messages by ID.
 
@@ -246,9 +247,9 @@ def _format_messages(messages: Sequence[BaseMessage]) -> list[BaseMessage]:
 
 
 def push_message(
-    message: Union[MessageLikeRepresentation, BaseMessageChunk],
+    message: MessageLikeRepresentation | BaseMessageChunk,
     *,
-    state_key: Optional[str] = "messages",
+    state_key: str | None = "messages",
 ) -> AnyMessage:
     """Write a message manually to the `messages` / `messages-tuple` stream mode.
 

libs/langgraph/langgraph/graph/state.py

@@ -15,7 +15,6 @@ from typing import (
     Generic,
     Literal,
     NamedTuple,
-    Optional,
     Protocol,
     Union,
     cast,
@@ -27,8 +26,9 @@ from typing import (
 
 from langchain_core.runnables import Runnable, RunnableConfig
 from pydantic import BaseModel
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self, TypeAlias, Unpack
 
+from langgraph._typing import UNSET, DeprecatedKwargs
 from langgraph.cache.base import BaseCache
 from langgraph.channels.base import BaseChannel
 from langgraph.channels.binop import BinaryOperatorAggregate
@@ -78,7 +78,7 @@ from langgraph.types import (
     Send,
     StreamWriter,
 )
-from langgraph.typing import InputT, StateT, StateT_contra, Unset
+from langgraph.typing import InputT, OutputT, StateT, StateT_contra
 from langgraph.utils.fields import (
     get_cached_annotated_keys,
     get_field_default,
@@ -86,11 +86,12 @@ from langgraph.utils.fields import (
 )
 from langgraph.utils.pydantic import create_model
 from langgraph.utils.runnable import coerce_to_runnable
+from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 logger = logging.getLogger(__name__)
 
 
-def _warn_invalid_state_schema(schema: Union[type[Any], Any]) -> None:
+def _warn_invalid_state_schema(schema: type[Any] | Any) -> None:
     if isinstance(schema, type):
         return
     if typing.get_args(schema):
@@ -173,15 +174,17 @@ class StateNodeSpec(NamedTuple):
     # TODO: rename this callable, also move away from NamedTuple so that we can use
     # a generic StateNode, so maybe a dataclass
     runnable: StateNode
-    metadata: Optional[dict[str, Any]]
+    metadata: dict[str, Any] | None
+    # TODO: rename to input_schema, though we really just want to modify this structure to
+    # be a dataclass
     input: type[Any]
-    retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]]
-    cache_policy: Optional[CachePolicy]
-    ends: Optional[Union[tuple[str, ...], dict[str, str]]] = EMPTY_SEQ
+    retry_policy: RetryPolicy | Sequence[RetryPolicy] | None
+    cache_policy: CachePolicy | None
+    ends: tuple[str, ...] | dict[str, str] | None = EMPTY_SEQ
     defer: bool = False
 
 
-class StateGraph(Generic[StateT, InputT]):
+class StateGraph(Generic[StateT, InputT, OutputT]):
     """A graph whose nodes communicate by reading and writing to a shared state.
     The signature of each node is State -> Partial<State>.
 
@@ -238,35 +241,58 @@ class StateGraph(Generic[StateT, InputT]):
     branches: defaultdict[str, dict[str, Branch]]
     channels: dict[str, BaseChannel]
     managed: dict[str, ManagedValueSpec]
-    schemas: dict[type[Any], dict[str, Union[BaseChannel, ManagedValueSpec]]]
+    schemas: dict[type[Any], dict[str, BaseChannel | ManagedValueSpec]]
+    waiting_edges: set[tuple[tuple[str, ...], str]]
+
+    compiled: bool
+    state_schema: type[StateT]
+    input_schema: type[InputT]
+    output_schema: type[OutputT]
 
     def __init__(
         self,
         state_schema: type[StateT],
         config_schema: type[Any] | None = None,
         *,
-        input: type[InputT] | None = None,
-        output: type[Any] | None = None,
+        input_schema: type[InputT] | None = None,
+        output_schema: type[OutputT] | None = None,
+        **kwargs: Unpack[DeprecatedKwargs],
     ) -> None:
-        input = input or state_schema
-        output = output or state_schema
+        if (input_ := kwargs.get("input", UNSET)) is not UNSET:
+            warnings.warn(
+                "`input` is deprecated and will be removed. Please use `input_schema` instead.",
+                category=LangGraphDeprecatedSinceV10,
+                stacklevel=2,
+            )
+            if input_schema is None:
+                input_schema = cast(Union[type[InputT], None], input_)
+
+        if (output := kwargs.get("output", UNSET)) is not UNSET:
+            warnings.warn(
+                "`output` is deprecated and will be removed. Please use `output_schema` instead.",
+                category=LangGraphDeprecatedSinceV10,
+                stacklevel=2,
+            )
+            if output_schema is None:
+                output_schema = cast(Union[type[OutputT], None], output)
 
         self.nodes = {}
-        self.edges = set[tuple[str, str]]()
+        self.edges = set()
         self.branches = defaultdict(dict)
-        self.support_multiple_edges = False
-        self.compiled = False
         self.schemas = {}
         self.channels = {}
         self.managed = {}
-        self.schema = state_schema
-        self.input = input
-        self.output = output
-        self._add_schema(state_schema)
-        self._add_schema(input, allow_managed=False)
-        self._add_schema(output, allow_managed=False)
+        self.compiled = False
+        self.waiting_edges = set()
+
+        self.state_schema = state_schema
+        self.input_schema = cast(type[InputT], input_schema or state_schema)
+        self.output_schema = cast(type[OutputT], output_schema or state_schema)
         self.config_schema = config_schema
-        self.waiting_edges: set[tuple[tuple[str, ...], str]] = set()
+
+        self._add_schema(self.state_schema)
+        self._add_schema(self.input_schema, allow_managed=False)
+        self._add_schema(self.output_schema, allow_managed=False)
 
     @property
     def _all_edges(self) -> set[tuple[str, str]]:
@@ -312,11 +338,12 @@ class StateGraph(Generic[StateT, InputT]):
         node: StateNode[StateT],
         *,
         defer: bool = False,
-        metadata: Optional[dict[str, Any]] = None,
-        input: Optional[type[Any]] = None,
-        retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        cache_policy: Optional[CachePolicy] = None,
-        destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
+        metadata: dict[str, Any] | None = None,
+        input_schema: type[Any] | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        cache_policy: CachePolicy | None = None,
+        destinations: dict[str, str] | tuple[str, ...] | None = None,
+        **kwargs: Unpack[DeprecatedKwargs],
     ) -> Self:
         """Add a new node to the state graph.
         Will take the name of the function/runnable as the node name.
@@ -330,26 +357,28 @@ class StateGraph(Generic[StateT, InputT]):
         action: StateNode[StateT],
         *,
         defer: bool = False,
-        metadata: Optional[dict[str, Any]] = None,
-        input: Optional[type[Any]] = None,
-        retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        cache_policy: Optional[CachePolicy] = None,
-        destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
+        metadata: dict[str, Any] | None = None,
+        input_schema: type[Any] | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        cache_policy: CachePolicy | None = None,
+        destinations: dict[str, str] | tuple[str, ...] | None = None,
+        **kwargs: Unpack[DeprecatedKwargs],
     ) -> Self:
         """Add a new node to the state graph."""
         ...
 
     def add_node(
         self,
-        node: Union[str, StateNode[StateT]],
-        action: Optional[StateNode[StateT]] = None,
+        node: str | StateNode[StateT],
+        action: StateNode[StateT] | None = None,
         *,
         defer: bool = False,
-        metadata: Optional[dict[str, Any]] = None,
-        input: Optional[type[Any]] = None,
-        retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        cache_policy: Optional[CachePolicy] = None,
-        destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
+        metadata: dict[str, Any] | None = None,
+        input_schema: type[Any] | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        cache_policy: CachePolicy | None = None,
+        destinations: dict[str, str] | tuple[str, ...] | None = None,
+        **kwargs: Unpack[DeprecatedKwargs],
     ) -> Self:
         """Add a new node to the state graph.
 
@@ -360,8 +389,8 @@ class StateGraph(Generic[StateT, InputT]):
                 Will be used as the node function or runnable if `node` is a string (node name).
             defer: Whether to defer the execution of the node until the run is about to end.
             metadata: The metadata associated with the node. (default: None)
-            input: The input schema for the node. (default: the graph's input schema)
-            retry: The policy for retrying the node. (default: None)
+            input_schema: The input schema for the node. (default: the graph's state schema)
+            retry_policy: The retry policy for the node. (default: None)
                 If a sequence is provided, the first matching policy will be applied.
             cache_policy: The cache policy for the node. (default: None)
             destinations: Destinations that indicate where a node can route to.
@@ -372,12 +401,18 @@ class StateGraph(Generic[StateT, InputT]):
 
         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()
@@ -387,7 +422,7 @@ class StateGraph(Generic[StateT, InputT]):
 
         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()
@@ -398,6 +433,22 @@ class StateGraph(Generic[StateT, InputT]):
         Returns:
             Self: The instance of the state graph, allowing for method chaining.
         """
+        if (retry := kwargs.get("retry", UNSET)) is not UNSET:
+            warnings.warn(
+                "`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
+                category=LangGraphDeprecatedSinceV10,
+            )
+            if retry_policy is None:
+                retry_policy = retry  # type: ignore[assignment]
+
+        if (input_ := kwargs.get("input", UNSET)) is not UNSET:
+            warnings.warn(
+                "`input` is deprecated and will be removed. Please use `input_schema` instead.",
+                category=LangGraphDeprecatedSinceV10,
+            )
+            if input_schema is None:
+                input_schema = cast(Union[type[InputT], None], input_)
+
         if not isinstance(node, str):
             action = node
             if isinstance(action, Runnable):
@@ -433,7 +484,7 @@ class StateGraph(Generic[StateT, InputT]):
                     f"'{character}' is a reserved character and is not allowed in the node names."
                 )
 
-        ends: Union[tuple[str, ...], dict[str, str]] = EMPTY_SEQ
+        ends: tuple[str, ...] | dict[str, str] = EMPTY_SEQ
         try:
             if (
                 isfunction(action)
@@ -443,7 +494,7 @@ class StateGraph(Generic[StateT, InputT]):
                 hints := get_type_hints(getattr(action, "__call__"))
                 or get_type_hints(action)
             ):
-                if input is None:
+                if input_schema is None:
                     first_parameter_name = next(
                         iter(
                             inspect.signature(
@@ -453,7 +504,7 @@ class StateGraph(Generic[StateT, InputT]):
                     )
                     if input_hint := hints.get(first_parameter_name):
                         if isinstance(input_hint, type) and get_type_hints(input_hint):
-                            input = input_hint
+                            input_schema = input_hint
                 if rtn := hints.get("return"):
                     # Handle Union types
                     rtn_origin = get_origin(rtn)
@@ -481,20 +532,20 @@ class StateGraph(Generic[StateT, InputT]):
         if destinations is not None:
             ends = destinations
 
-        if input is not None:
-            self._add_schema(input)
+        if input_schema is not None:
+            self._add_schema(input_schema)
         self.nodes[node] = StateNodeSpec(
             coerce_to_runnable(action, name=node, trace=False),  # type: ignore
             metadata,
-            input=input or self.schema,
-            retry_policy=retry,
+            input=input_schema or self.state_schema,
+            retry_policy=retry_policy,
             cache_policy=cache_policy,
             ends=ends,
             defer=defer,
         )
         return self
 
-    def add_edge(self, start_key: Union[str, list[str]], end_key: str) -> Self:
+    def add_edge(self, start_key: str | list[str], end_key: str) -> Self:
         """Add a directed edge from the start node (or list of start nodes) to the end node.
 
         When a single start node is provided, the graph will wait for that node to complete
@@ -551,12 +602,10 @@ class StateGraph(Generic[StateT, InputT]):
     def add_conditional_edges(
         self,
         source: str,
-        path: Union[
-            Callable[..., Union[Hashable, list[Hashable]]],
-            Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
-            Runnable[Any, Union[Hashable, list[Hashable]]],
-        ],
-        path_map: Optional[Union[dict[Hashable, str], list[str]]] = None,
+        path: Callable[..., Hashable | list[Hashable]]
+        | Callable[..., Awaitable[Hashable | list[Hashable]]]
+        | Runnable[Any, Hashable | list[Hashable]],
+        path_map: dict[Hashable, str] | list[str] | None = None,
     ) -> Self:
         """Add a conditional edge from the starting node to any number of destination nodes.
 
@@ -598,7 +647,7 @@ class StateGraph(Generic[StateT, InputT]):
 
     def add_sequence(
         self,
-        nodes: Sequence[Union[StateNode[StateT], tuple[str, StateNode[StateT]]]],
+        nodes: Sequence[StateNode[StateT] | tuple[str, StateNode[StateT]]],
     ) -> Self:
         """Add a sequence of nodes that will be executed in the provided order.
 
@@ -617,7 +666,7 @@ class StateGraph(Generic[StateT, InputT]):
         if len(nodes) < 1:
             raise ValueError("Sequence requires at least one node.")
 
-        previous_name: Optional[str] = None
+        previous_name: str | None = None
         for node in nodes:
             if isinstance(node, tuple) and len(node) == 2:
                 name, node = node
@@ -653,12 +702,10 @@ class StateGraph(Generic[StateT, InputT]):
 
     def set_conditional_entry_point(
         self,
-        path: Union[
-            Callable[..., Union[Hashable, list[Hashable]]],
-            Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
-            Runnable[Any, Union[Hashable, list[Hashable]]],
-        ],
-        path_map: Optional[Union[dict[Hashable, str], list[str]]] = None,
+        path: Callable[..., Hashable | list[Hashable]]
+        | Callable[..., Awaitable[Hashable | list[Hashable]]]
+        | Runnable[Any, Hashable | list[Hashable]],
+        path_map: dict[Hashable, str] | list[str] | None = None,
     ) -> Self:
         """Sets a conditional entry point in the graph.
 
@@ -687,7 +734,7 @@ class StateGraph(Generic[StateT, InputT]):
         """
         return self.add_edge(key, END)
 
-    def validate(self, interrupt: Optional[Sequence[str]] = None) -> Self:
+    def validate(self, interrupt: Sequence[str] | None = None) -> Self:
         # assemble sources
         all_sources = {src for src, _ in self._all_edges}
         for start, branches in self.branches.items():
@@ -736,43 +783,17 @@ class StateGraph(Generic[StateT, InputT]):
         self.compiled = True
         return self
 
-    @overload
-    def compile(
-        self: StateGraph[StateT, Unset],
-        checkpointer: Checkpointer = None,
-        *,
-        cache: Optional[BaseCache] = None,
-        store: Optional[BaseStore] = None,
-        interrupt_before: Optional[Union[All, list[str]]] = None,
-        interrupt_after: Optional[Union[All, list[str]]] = None,
-        debug: bool = False,
-        name: Optional[str] = None,
-    ) -> CompiledStateGraph[StateT, StateT]: ...
-
-    @overload
-    def compile(
-        self: StateGraph[StateT, InputT],
-        checkpointer: Checkpointer = None,
-        *,
-        cache: Optional[BaseCache] = None,
-        store: Optional[BaseStore] = None,
-        interrupt_before: Optional[Union[All, list[str]]] = None,
-        interrupt_after: Optional[Union[All, list[str]]] = None,
-        debug: bool = False,
-        name: Optional[str] = None,
-    ) -> CompiledStateGraph[StateT, InputT]: ...
-
     def compile(
         self,
         checkpointer: Checkpointer = None,
         *,
-        cache: Optional[BaseCache] = None,
-        store: Optional[BaseStore] = None,
-        interrupt_before: Optional[Union[All, list[str]]] = None,
-        interrupt_after: Optional[Union[All, list[str]]] = None,
+        cache: BaseCache | None = None,
+        store: BaseStore | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
         debug: bool = False,
-        name: Optional[str] = None,
-    ) -> Union[CompiledStateGraph[StateT, StateT], CompiledStateGraph[StateT, InputT]]:
+        name: str | None = None,
+    ) -> CompiledStateGraph[StateT, InputT]:
         """Compiles the state graph into a `CompiledStateGraph` object.
 
         The compiled graph implements the `Runnable` interface and can be invoked,
@@ -808,11 +829,11 @@ class StateGraph(Generic[StateT, InputT]):
         # prepare output channels
         output_channels = (
             "__root__"
-            if len(self.schemas[self.output]) == 1
-            and "__root__" in self.schemas[self.output]
+            if len(self.schemas[self.output_schema]) == 1
+            and "__root__" in self.schemas[self.output_schema]
             else [
                 key
-                for key, val in self.schemas[self.output].items()
+                for key, val in self.schemas[self.output_schema].items()
                 if not is_managed_value(val)
             ]
         )
@@ -824,23 +845,15 @@ class StateGraph(Generic[StateT, InputT]):
             ]
         )
 
-        ResolvedInputT: Union[type[InputT], type[StateT]] = self.input or self.schema
-        compiled = CompiledStateGraph[StateT, ResolvedInputT](  # type: ignore[valid-type]
+        compiled = CompiledStateGraph[StateT, InputT, OutputT](
             builder=self,
             schema_to_mapper={},
             config_type=self.config_schema,
-            input_model=(
-                self.input
-                if len(self.channels) > 1
-                and isclass(self.input)
-                and issubclass(self.input, BaseModel)
-                else None
-            ),
             nodes={},
             channels={
                 **self.channels,
                 **self.managed,
-                START: EphemeralValue(self.input),
+                START: EphemeralValue(self.input_schema),
             },
             input_channels=START,
             stream_mode="updates",
@@ -873,46 +886,46 @@ class StateGraph(Generic[StateT, InputT]):
         return compiled.validate()
 
 
-class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
-    builder: StateGraph[StateT, InputT]
-    schema_to_mapper: dict[type[Any], Optional[Callable[[Any], Any]]]
+class CompiledStateGraph(
+    Pregel[StateT, InputT, OutputT], Generic[StateT, InputT, OutputT]
+):
+    builder: StateGraph[StateT, InputT, OutputT]
+    schema_to_mapper: dict[type[Any], Callable[[Any], Any] | None]
 
     def __init__(
         self,
         *,
-        builder: StateGraph[StateT, InputT],
-        schema_to_mapper: dict[type[Any], Optional[Callable[[Any], Any]]],
+        builder: StateGraph[StateT, InputT, OutputT],
+        schema_to_mapper: dict[type[Any], Callable[[Any], Any] | None],
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
         self.builder = builder
         self.schema_to_mapper = schema_to_mapper
 
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         return _get_schema(
-            typ=self.builder.input,
+            typ=self.builder.input_schema,
             schemas=self.builder.schemas,
             channels=self.builder.channels,
             name=self.get_name("Input"),
         )
 
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         return _get_schema(
-            typ=self.builder.output,
+            typ=self.builder.output_schema,
             schemas=self.builder.schemas,
             channels=self.builder.channels,
             name=self.get_name("Output"),
         )
 
-    def attach_node(self, key: str, node: Optional[StateNodeSpec]) -> None:
+    def attach_node(self, key: str, node: StateNodeSpec | None) -> None:
         if key == START:
             output_keys = [
                 k
-                for k, v in self.builder.schemas[self.builder.input].items()
+                for k, v in self.builder.schemas[self.builder.input_schema].items()
                 if not is_managed_value(v)
             ]
         else:
@@ -921,8 +934,8 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
             ]
 
         def _get_updates(
-            input: Union[None, dict, Any],
-        ) -> Optional[Sequence[tuple[str, Any]]]:
+            input: None | dict | Any,
+        ) -> Sequence[tuple[str, Any]] | None:
             if input is None:
                 return None
             elif isinstance(input, dict):
@@ -959,7 +972,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
                 raise InvalidUpdateError(msg)
 
         # state updaters
-        write_entries: tuple[Union[ChannelWriteEntry, ChannelWriteTupleEntry], ...] = (
+        write_entries: tuple[ChannelWriteEntry | ChannelWriteTupleEntry, ...] = (
             ChannelWriteTupleEntry(
                 mapper=_get_root if output_keys == ["__root__"] else _get_updates
             ),
@@ -976,20 +989,17 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
             self.nodes[key] = PregelNode(
                 tags=[TAG_HIDDEN],
                 triggers=[START],
-                channels=[START],
+                channels=START,
                 writers=[ChannelWrite(write_entries)],
             )
         elif node is not None:
-            input_schema = node.input if node else self.builder.schema
-            input_values = {k: k for k in self.builder.schemas[input_schema]}
-            is_single_input = len(input_values) == 1 and "__root__" in input_values
+            input_schema = node.input if node else self.builder._state_schema
+            input_channels = list(self.builder.schemas[input_schema])
+            is_single_input = len(input_channels) == 1 and "__root__" in input_channels
             if input_schema in self.schema_to_mapper:
                 mapper = self.schema_to_mapper[input_schema]
             else:
-                mapper = _pick_mapper(
-                    list(input_values),
-                    input_schema,
-                )
+                mapper = _pick_mapper(input_channels, input_schema)
                 self.schema_to_mapper[input_schema] = mapper
 
             branch_channel = CHANNEL_BRANCH_TO.format(key)
@@ -1001,7 +1011,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
             self.nodes[key] = PregelNode(
                 triggers=[branch_channel],
                 # read state keys and managed values
-                channels=(list(input_values) if is_single_input else input_values),
+                channels=("__root__" if is_single_input else input_channels),
                 # coerce state dict to schema class (eg. pydantic model)
                 mapper=mapper,
                 # publish to state keys
@@ -1014,7 +1024,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
         else:
             raise RuntimeError
 
-    def attach_edge(self, starts: Union[str, Sequence[str]], end: str) -> None:
+    def attach_edge(self, starts: str | Sequence[str], end: str) -> None:
         if isinstance(starts, str):
             # subscribe to start channel
             if end != END:
@@ -1044,8 +1054,8 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
         self, start: str, name: str, branch: Branch, *, with_reader: bool = True
     ) -> None:
         def get_writes(
-            packets: Sequence[Union[str, Send]], static: bool = False
-        ) -> Sequence[Union[ChannelWriteEntry, Send]]:
+            packets: Sequence[str | Send], static: bool = False
+        ) -> Sequence[ChannelWriteEntry | Send]:
             writes = [
                 (
                     ChannelWriteEntry(
@@ -1066,7 +1076,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
             schema = branch.input_schema or (
                 self.builder.nodes[start].input
                 if start in self.builder.nodes
-                else self.builder.schema
+                else self.builder.state_schema
             )
             channels = list(self.builder.schemas[schema])
             # get mapper
@@ -1076,7 +1086,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
                 mapper = _pick_mapper(channels, schema)
                 self.schema_to_mapper[schema] = mapper
             # create reader
-            reader: Optional[Callable[[RunnableConfig], Any]] = partial(
+            reader: Callable[[RunnableConfig], Any] | None = partial(
                 ChannelRead.do_read,
                 select=channels[0] if channels == ["__root__"] else channels,
                 fresh=True,
@@ -1196,7 +1206,7 @@ class CompiledStateGraph(Pregel[InputT], Generic[StateT, InputT]):
 
 def _pick_mapper(
     state_keys: Sequence[str], schema: type[Any]
-) -> Optional[Callable[[Any], Any]]:
+) -> Callable[[Any], Any] | None:
     if state_keys == ["__root__"]:
         return None
     if isclass(schema) and issubclass(schema, dict):
@@ -1237,8 +1247,8 @@ def _control_branch(value: Any) -> Sequence[tuple[str, Any]]:
 
 
 def _control_static(
-    ends: Union[tuple[str, ...], dict[str, str]],
-) -> Sequence[tuple[str, Any, Optional[str]]]:
+    ends: tuple[str, ...] | dict[str, str],
+) -> Sequence[tuple[str, Any, str | None]]:
     if isinstance(ends, dict):
         return [
             (k if k == END else CHANNEL_BRANCH_TO.format(k), None, label)
@@ -1250,7 +1260,7 @@ def _control_static(
         ]
 
 
-def _get_root(input: Any) -> Optional[Sequence[tuple[str, Any]]]:
+def _get_root(input: Any) -> Sequence[tuple[str, Any]] | None:
     if isinstance(input, Command):
         if input.graph == Command.PARENT:
             return ()
@@ -1305,12 +1315,12 @@ def _get_channel(
 @overload
 def _get_channel(
     name: str, annotation: Any, *, allow_managed: Literal[True] = True
-) -> Union[BaseChannel, ManagedValueSpec]: ...
+) -> BaseChannel | ManagedValueSpec: ...
 
 
 def _get_channel(
     name: str, annotation: Any, *, allow_managed: bool = True
-) -> Union[BaseChannel, ManagedValueSpec]:
+) -> BaseChannel | ManagedValueSpec:
     if manager := _is_field_managed_value(name, annotation):
         if allow_managed:
             return manager
@@ -1328,7 +1338,7 @@ def _get_channel(
     return fallback
 
 
-def _is_field_channel(typ: type[Any]) -> Optional[BaseChannel]:
+def _is_field_channel(typ: type[Any]) -> BaseChannel | None:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1 and isinstance(meta[-1], BaseChannel):
@@ -1338,7 +1348,7 @@ def _is_field_channel(typ: type[Any]) -> Optional[BaseChannel]:
     return None
 
 
-def _is_field_binop(typ: type[Any]) -> Optional[BinaryOperatorAggregate]:
+def _is_field_binop(typ: type[Any]) -> BinaryOperatorAggregate | None:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1 and callable(meta[-1]):
@@ -1359,7 +1369,7 @@ def _is_field_binop(typ: type[Any]) -> Optional[BinaryOperatorAggregate]:
     return None
 
 
-def _is_field_managed_value(name: str, typ: type[Any]) -> Optional[ManagedValueSpec]:
+def _is_field_managed_value(name: str, typ: type[Any]) -> ManagedValueSpec | None:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1:

libs/langgraph/langgraph/graph/ui.py

@@ -1,4 +1,6 @@
-from typing import Any, Literal, Optional, Union, cast
+from __future__ import annotations
+
+from typing import Any, Literal, Union, cast
 from uuid import uuid4
 
 from langchain_core.messages import AnyMessage
@@ -51,10 +53,10 @@ def push_ui_message(
     name: str,
     props: dict[str, Any],
     *,
-    id: Optional[str] = None,
-    metadata: Optional[dict[str, Any]] = None,
-    message: Optional[AnyMessage] = None,
-    state_key: Optional[str] = "ui",
+    id: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    message: AnyMessage | None = None,
+    state_key: str | None = "ui",
     merge: bool = False,
 ) -> UIMessage:
     """Push a new UI message to update the UI state.
@@ -149,8 +151,8 @@ def delete_ui_message(id: str, *, state_key: str = "ui") -> RemoveUIMessage:
 
 
 def ui_message_reducer(
-    left: Union[list[AnyUIMessage], AnyUIMessage],
-    right: Union[list[AnyUIMessage], AnyUIMessage],
+    left: list[AnyUIMessage] | AnyUIMessage,
+    right: list[AnyUIMessage] | AnyUIMessage,
 ) -> list[AnyUIMessage]:
     """Merge two lists of UI messages, supporting removing UI messages.
 

libs/langgraph/langgraph/pregel/__init__.py

@@ -60,7 +60,6 @@ from langgraph.constants import (
     NS_SEP,
     NULL_TASK_ID,
     PUSH,
-    SCHEDULED,
     TASKS,
 )
 from langgraph.errors import (
@@ -107,7 +106,7 @@ from langgraph.types import (
     StreamChunk,
     StreamMode,
 )
-from langgraph.typing import InputT
+from langgraph.typing import InputT, OutputT, StateT
 from langgraph.utils.config import (
     ensure_config,
     merge_configs,
@@ -141,40 +140,38 @@ class NodeBuilder:
         "_metadata",
         "_writes",
         "_bound",
-        "_retries",
-        "_cache",
+        "_retry_policy",
+        "_cache_policy",
     )
 
-    _channels: list[str] | dict[str, str]
+    _channels: str | list[str]
     _triggers: list[str]
     _tags: list[str]
     _metadata: dict[str, Any]
     _writes: list[ChannelWriteEntry]
     _bound: Runnable
-    _retries: list[RetryPolicy]
-    _cache: CachePolicy | None
+    _retry_policy: list[RetryPolicy]
+    _cache_policy: CachePolicy | None
 
     def __init__(
         self,
     ) -> None:
-        self._channels = {}
+        self._channels = []
         self._triggers = []
         self._tags = []
         self._metadata = {}
         self._writes = []
         self._bound = DEFAULT_BOUND
-        self._retries = []
-        self._cache = None
+        self._retry_policy = []
+        self._cache_policy = None
 
     def subscribe_only(
         self,
         channel: str,
     ) -> Self:
         """Subscribe to a single channel."""
-        if isinstance(self._channels, list):
-            self._channels.append(channel)
-        elif not self._channels:
-            self._channels = [channel]
+        if not self._channels:
+            self._channels = channel
         else:
             raise ValueError(
                 "Cannot subscribe to single channels when other channels are already subscribed to"
@@ -200,15 +197,15 @@ class NodeBuilder:
         Returns:
             Self for chaining
         """
-        if isinstance(self._channels, list):
+        if isinstance(self._channels, str):
             raise ValueError(
                 "Cannot subscribe to channels when subscribed to a single channel"
             )
         if read:
             if not self._channels:
-                self._channels = {chan: chan for chan in channels}
+                self._channels = list(channels)
             else:
-                self._channels.update({chan: chan for chan in channels})
+                self._channels.extend(channels)
 
         if isinstance(channels, str):
             self._triggers.append(channels)
@@ -222,11 +219,10 @@ class NodeBuilder:
         *channels: str,
     ) -> Self:
         """Adds the specified channels to read from, without subscribing to them."""
-        assert self._channels, "Channels must be specified first"
-        assert isinstance(self._channels, dict), (
+        assert isinstance(self._channels, list), (
             "Cannot read additional channels when subscribed to single channels"
         )
-        self._channels.update({c: c for c in channels})
+        self._channels.extend(channels)
         return self
 
     def do(
@@ -274,14 +270,14 @@ class NodeBuilder:
         self._metadata.update(metadata)
         return self
 
-    def retry(self, *policies: RetryPolicy) -> Self:
+    def add_retry_policies(self, *policies: RetryPolicy) -> Self:
         """Adds retry policies to the node."""
-        self._retries.extend(policies)
+        self._retry_policy.extend(policies)
         return self
 
-    def cache(self, policy: CachePolicy) -> Self:
+    def add_cache_policy(self, policy: CachePolicy) -> Self:
         """Adds cache policies to the node."""
-        self._cache = policy
+        self._cache_policy = policy
         return self
 
     def build(self) -> PregelNode:
@@ -293,12 +289,12 @@ class NodeBuilder:
             metadata=self._metadata,
             writers=[ChannelWrite(self._writes)],
             bound=self._bound,
-            retry_policy=self._retries,
-            cache_policy=self._cache,
+            retry_policy=self._retry_policy,
+            cache_policy=self._cache_policy,
         )
 
 
-class Pregel(PregelProtocol[InputT], Generic[InputT]):
+class Pregel(PregelProtocol[StateT, InputT, OutputT], Generic[StateT, InputT, OutputT]):
     """Pregel manages the runtime behavior for LangGraph applications.
 
     ## Overview
@@ -593,8 +589,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
 
     config_type: type[Any] | None = None
 
-    input_model: type[BaseModel] | None = None
-
     config: RunnableConfig | None = None
 
     name: str = "LangGraph"
@@ -622,7 +616,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
         retry_policy: RetryPolicy | Sequence[RetryPolicy] = (),
         cache_policy: CachePolicy | None = None,
         config_type: type[Any] | None = None,
-        input_model: type[BaseModel] | None = None,
         config: RunnableConfig | None = None,
         trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
         name: str = "LangGraph",
@@ -654,7 +647,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
         )
         self.cache_policy = cache_policy
         self.config_type = config_type
-        self.input_model = input_model
         self.config = config
         self.trigger_to_nodes = trigger_to_nodes or {}
         self.name = name
@@ -753,6 +745,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
         validate_graph(
             self.nodes,
             {k: v for k, v in self.channels.items() if isinstance(v, BaseChannel)},
+            {k: v for k, v in self.channels.items() if not isinstance(v, BaseChannel)},
             self.input_channels,
             self.output_channels,
             self.stream_channels,
@@ -791,8 +784,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 return channel.UpdateType
 
     def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
-        if self.input_model is not None:
-            return self.input_model
         config = merge_configs(self.config, config)
         if isinstance(self.input_channels, str):
             return super().get_input_schema(config)
@@ -1011,7 +1002,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
             )
         if apply_pending_writes and saved.pending_writes:
             for tid, k, v in saved.pending_writes:
-                if k in (ERROR, INTERRUPT, SCHEDULED):
+                if k in (ERROR, INTERRUPT):
                     continue
                 if tid not in next_tasks:
                     continue
@@ -1130,7 +1121,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
             )
         if apply_pending_writes and saved.pending_writes:
             for tid, k, v in saved.pending_writes:
-                if k in (ERROR, INTERRUPT, SCHEDULED):
+                if k in (ERROR, INTERRUPT):
                     continue
                 if tid not in next_tasks:
                     continue
@@ -1469,7 +1460,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                         )
                     # apply writes from tasks that already ran
                     for tid, k, v in saved.pending_writes or []:
-                        if k in (ERROR, INTERRUPT, SCHEDULED):
+                        if k in (ERROR, INTERRUPT):
                             continue
                         if tid not in next_tasks:
                             continue
@@ -1633,7 +1624,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                     )
                 # apply writes
                 for tid, k, v in saved.pending_writes:
-                    if k in (ERROR, INTERRUPT, SCHEDULED):
+                    if k in (ERROR, INTERRUPT):
                         continue
                     if tid not in next_tasks:
                         continue
@@ -1889,7 +1880,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                         )
                     # apply writes from tasks that already ran
                     for tid, k, v in saved.pending_writes or []:
-                        if k in (ERROR, INTERRUPT, SCHEDULED):
+                        if k in (ERROR, INTERRUPT):
                             continue
                         if tid not in next_tasks:
                             continue
@@ -2052,7 +2043,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                         self.trigger_to_nodes,
                     )
                 for tid, k, v in saved.pending_writes:
-                    if k in (ERROR, INTERRUPT, SCHEDULED):
+                    if k in (ERROR, INTERRUPT):
                         continue
                     if tid not in next_tasks:
                         continue
@@ -2407,7 +2398,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 config[CONF][CONFIG_KEY_CHECKPOINT_DURING] = checkpoint_during
             with SyncPregelLoop(
                 input,
-                input_model=self.input_model,
                 stream=StreamProtocol(stream.put, stream_modes),
                 config=config,
                 store=store,
@@ -2416,6 +2406,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 nodes=self.nodes,
                 specs=self.channels,
                 output_keys=output_keys,
+                input_keys=self.input_channels,
                 stream_keys=self.stream_channels_asis,
                 interrupt_before=interrupt_before_,
                 interrupt_after=interrupt_after_,
@@ -2470,7 +2461,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 # Channel updates from step N are only visible in step N+1
                 # channels are guaranteed to be immutable for the duration of the step,
                 # with channel updates applied only at the transition between steps.
-                while loop.tick(input_keys=self.input_channels):
+                while loop.tick():
                     for task in loop.match_cached_writes():
                         loop.output_writes(task.id, task.writes, cached=True)
                     for _ in runner.tick(
@@ -2481,6 +2472,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                     ):
                         # emit output
                         yield from output()
+                    loop.after_tick()
             # emit output
             yield from output()
             # handle exit
@@ -2650,7 +2642,6 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 config[CONF][CONFIG_KEY_CHECKPOINT_DURING] = checkpoint_during
             async with AsyncPregelLoop(
                 input,
-                input_model=self.input_model,
                 stream=StreamProtocol(stream.put_nowait, stream_modes),
                 config=config,
                 store=store,
@@ -2659,6 +2650,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 nodes=self.nodes,
                 specs=self.channels,
                 output_keys=output_keys,
+                input_keys=self.input_channels,
                 stream_keys=self.stream_channels_asis,
                 interrupt_before=interrupt_before_,
                 interrupt_after=interrupt_after_,
@@ -2704,7 +2696,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                 # channel updates from step N are only visible in step N+1
                 # channels are guaranteed to be immutable for the duration of the step,
                 # with channel updates applied only at the transition between steps
-                while loop.tick(input_keys=self.input_channels):
+                while loop.tick():
                     for task in await loop.amatch_cached_writes():
                         loop.output_writes(task.id, task.writes, cached=True)
                     async for _ in runner.atick(
@@ -2716,6 +2708,7 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
                         # emit output
                         for o in output():
                             yield o
+                    loop.after_tick()
             # emit output
             for o in output():
                 yield o
@@ -2766,8 +2759,8 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
         """
         output_keys = output_keys if output_keys is not None else self.output_channels
 
-        latest: Union[dict[str, Any], Any] = None
-        chunks: list[Union[dict[str, Any], Any]] = []
+        latest: dict[str, Any] | Any = None
+        chunks: list[dict[str, Any] | Any] = []
         interrupts: list[Interrupt] = []
 
         for chunk in self.stream(
@@ -2833,8 +2826,8 @@ class Pregel(PregelProtocol[InputT], Generic[InputT]):
 
         output_keys = output_keys if output_keys is not None else self.output_channels
 
-        latest: Union[dict[str, Any], Any] = None
-        chunks: list[Union[dict[str, Any], Any]] = []
+        latest: dict[str, Any] | Any = None
+        chunks: list[dict[str, Any] | Any] = []
         interrupts: list[Interrupt] = []
 
         async for chunk in self.astream(

libs/langgraph/langgraph/pregel/algo.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import binascii
 import itertools
 import sys
@@ -14,7 +16,6 @@ from typing import (
     NamedTuple,
     Optional,
     Protocol,
-    Union,
     cast,
     overload,
 )
@@ -91,7 +92,7 @@ class WritesProtocol(Protocol):
     Implemented by PregelTaskWrites and PregelExecutableTask."""
 
     @property
-    def path(self) -> tuple[Union[str, int, tuple], ...]: ...
+    def path(self) -> tuple[str | int | tuple, ...]: ...
 
     @property
     def name(self) -> str: ...
@@ -107,19 +108,19 @@ class PregelTaskWrites(NamedTuple):
     """Simplest implementation of WritesProtocol, for usage with writes that
     don't originate from a runnable task, eg. graph input, update_state, etc."""
 
-    path: tuple[Union[str, int, tuple], ...]
+    path: tuple[str | int | tuple, ...]
     name: str
     writes: Sequence[tuple[str, Any]]
     triggers: Sequence[str]
 
 
 class Call:
-    __slots__ = ("func", "input", "retry", "cache_policy", "callbacks")
+    __slots__ = ("func", "input", "retry_policy", "cache_policy", "callbacks")
 
     func: Callable
     input: tuple[tuple[Any, ...], dict[str, Any]]
-    retry: Optional[Sequence[RetryPolicy]]
-    cache_policy: Optional[CachePolicy]
+    retry_policy: Sequence[RetryPolicy] | None
+    cache_policy: CachePolicy | None
     callbacks: Callbacks
 
     def __init__(
@@ -127,20 +128,20 @@ class Call:
         func: Callable,
         input: tuple[tuple[Any, ...], dict[str, Any]],
         *,
-        retry: Optional[Sequence[RetryPolicy]],
-        cache_policy: Optional[CachePolicy],
+        retry_policy: Sequence[RetryPolicy] | None,
+        cache_policy: CachePolicy | None,
         callbacks: Callbacks,
     ) -> None:
         self.func = func
         self.input = input
-        self.retry = retry
+        self.retry_policy = retry_policy
         self.cache_policy = cache_policy
         self.callbacks = callbacks
 
 
 def should_interrupt(
     checkpoint: Checkpoint,
-    interrupt_nodes: Union[All, Sequence[str]],
+    interrupt_nodes: All | Sequence[str],
     tasks: Iterable[PregelExecutableTask],
 ) -> list[PregelExecutableTask]:
     """Check if the graph should be interrupted based on current state."""
@@ -176,9 +177,9 @@ def local_read(
     channels: Mapping[str, BaseChannel],
     managed: ManagedValueMapping,
     task: WritesProtocol,
-    select: Union[list[str], str],
+    select: list[str] | str,
     fresh: bool = False,
-) -> Union[dict[str, Any], Any]:
+) -> dict[str, Any] | Any:
     """Function injected under CONFIG_KEY_READ in task config, to read current state.
     Used by conditional edges to read a copy of the state with reflecting the writes
     from that node only."""
@@ -213,7 +214,7 @@ def local_read(
     return values
 
 
-def increment(current: Optional[int]) -> int:
+def increment(current: int | None) -> int:
     """Default channel versioning function, increments the current int version."""
     return current + 1 if current is not None else 1
 
@@ -222,7 +223,7 @@ def apply_writes(
     checkpoint: Checkpoint,
     channels: Mapping[str, BaseChannel],
     tasks: Iterable[WritesProtocol],
-    get_next_version: Optional[GetNextVersion],
+    get_next_version: GetNextVersion | None,
     trigger_to_nodes: Mapping[str, Sequence[str]],
 ) -> set[str]:
     """Apply writes from a set of tasks (usually the tasks from a Pregel step)
@@ -338,8 +339,8 @@ def prepare_next_tasks(
     store: Literal[None] = None,
     checkpointer: Literal[None] = None,
     manager: Literal[None] = None,
-    trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
-    updated_channels: Optional[set[str]] = None,
+    trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
+    updated_channels: set[str] | None = None,
     retry_policy: Sequence[RetryPolicy] = (),
     cache_policy: Literal[None] = None,
 ) -> dict[str, PregelTask]: ...
@@ -357,13 +358,13 @@ def prepare_next_tasks(
     stop: int,
     *,
     for_execution: Literal[True],
-    store: Optional[BaseStore],
-    checkpointer: Optional[BaseCheckpointSaver],
-    manager: Union[None, ParentRunManager, AsyncParentRunManager],
-    trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
-    updated_channels: Optional[set[str]] = None,
+    store: BaseStore | None,
+    checkpointer: BaseCheckpointSaver | None,
+    manager: None | ParentRunManager | AsyncParentRunManager,
+    trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
+    updated_channels: set[str] | None = None,
     retry_policy: Sequence[RetryPolicy] = (),
-    cache_policy: Optional[CachePolicy] = None,
+    cache_policy: CachePolicy | None = None,
 ) -> dict[str, PregelExecutableTask]: ...
 
 
@@ -378,14 +379,14 @@ def prepare_next_tasks(
     stop: int,
     *,
     for_execution: bool,
-    store: Optional[BaseStore] = None,
-    checkpointer: Optional[BaseCheckpointSaver] = None,
-    manager: Union[None, ParentRunManager, AsyncParentRunManager] = None,
-    trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
-    updated_channels: Optional[set[str]] = None,
+    store: BaseStore | None = None,
+    checkpointer: BaseCheckpointSaver | None = None,
+    manager: None | ParentRunManager | AsyncParentRunManager = None,
+    trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
+    updated_channels: set[str] | None = None,
     retry_policy: Sequence[RetryPolicy] = (),
-    cache_policy: Optional[CachePolicy] = None,
-) -> Union[dict[str, PregelTask], dict[str, PregelExecutableTask]]:
+    cache_policy: CachePolicy | None = None,
+) -> dict[str, PregelTask] | dict[str, PregelExecutableTask]:
     """Prepare the set of tasks that will make up the next Pregel step.
 
     Args:
@@ -415,7 +416,7 @@ def prepare_next_tasks(
     input_cache: dict[INPUT_CACHE_KEY_TYPE, Any] = {}
     checkpoint_id_bytes = binascii.unhexlify(checkpoint["id"].replace("-", ""))
     null_version = checkpoint_null_version(checkpoint)
-    tasks: list[Union[PregelTask, PregelExecutableTask]] = []
+    tasks: list[PregelTask | PregelExecutableTask] = []
     # Consume pending tasks
     tasks_channel = cast(Optional[Topic[Send]], channels.get(TASKS))
     if tasks_channel and tasks_channel.is_available():
@@ -496,11 +497,11 @@ PUSH_TRIGGER = (PUSH,)
 
 def prepare_single_task(
     task_path: tuple[Any, ...],
-    task_id_checksum: Optional[str],
+    task_id_checksum: str | None,
     *,
     checkpoint: Checkpoint,
     checkpoint_id_bytes: bytes,
-    checkpoint_null_version: Optional[V],
+    checkpoint_null_version: V | None,
     pending_writes: list[PendingWrite],
     processes: Mapping[str, PregelNode],
     channels: Mapping[str, BaseChannel],
@@ -509,13 +510,13 @@ def prepare_single_task(
     step: int,
     stop: int,
     for_execution: bool,
-    store: Optional[BaseStore] = None,
-    checkpointer: Optional[BaseCheckpointSaver] = None,
-    manager: Union[None, ParentRunManager, AsyncParentRunManager] = None,
-    input_cache: Optional[dict[INPUT_CACHE_KEY_TYPE, Any]] = None,
-    cache_policy: Optional[CachePolicy] = None,
+    store: BaseStore | None = None,
+    checkpointer: BaseCheckpointSaver | None = None,
+    manager: None | ParentRunManager | AsyncParentRunManager = None,
+    input_cache: dict[INPUT_CACHE_KEY_TYPE, Any] | None = None,
+    cache_policy: CachePolicy | None = None,
     retry_policy: Sequence[RetryPolicy] = (),
-) -> Union[None, PregelTask, PregelExecutableTask]:
+) -> None | PregelTask | PregelExecutableTask:
     """Prepares a single task for the next Pregel step, given a task path, which
     uniquely identifies a PUSH or PULL task within the graph."""
     configurable = config.get(CONF, {})
@@ -560,7 +561,7 @@ def prepare_single_task(
             cache_policy = call.cache_policy or cache_policy
             if cache_policy:
                 args_key = cache_policy.key_func(*call.input[0], **call.input[1])
-                cache_key: Optional[CacheKey] = CacheKey(
+                cache_key: CacheKey | None = CacheKey(
                     (
                         CACHE_NS_WRITES,
                         (identifier(call.func) or "__dynamic__"),
@@ -616,7 +617,7 @@ def prepare_single_task(
                     },
                 ),
                 triggers,
-                call.retry or retry_policy,
+                call.retry_policy or retry_policy,
                 cache_key,
                 task_id,
                 task_path,
@@ -908,7 +909,7 @@ def prepare_single_task(
 
 def checkpoint_null_version(
     checkpoint: Checkpoint,
-) -> Optional[V]:
+) -> V | None:
     """Get the null version for the checkpoint, if available."""
     for version in checkpoint["channel_versions"].values():
         return type(version)()
@@ -918,29 +919,29 @@ def checkpoint_null_version(
 def _triggers(
     channels: Mapping[str, BaseChannel],
     versions: ChannelVersions,
-    seen: Optional[ChannelVersions],
+    seen: ChannelVersions | None,
     null_version: V,
     proc: PregelNode,
-) -> Sequence[str]:
+) -> bool:
     if seen is None:
         for chan in proc.triggers:
             if channels[chan].is_available():
-                return (chan,)
+                return True
     else:
         for chan in proc.triggers:
             if channels[chan].is_available() and versions.get(  # type: ignore[operator]
                 chan, null_version
             ) > seen.get(chan, null_version):
-                return (chan,)
-    return EMPTY_SEQ
+                return True
+    return False
 
 
 def _scratchpad(
-    parent_scratchpad: Optional[PregelScratchpad],
+    parent_scratchpad: PregelScratchpad | None,
     pending_writes: list[PendingWrite],
     task_id: str,
     namespace_hash: str,
-    resume_map: Optional[dict[str, Any]],
+    resume_map: dict[str, Any] | None,
     step: int,
     stop: int,
 ) -> PregelScratchpad:
@@ -1010,7 +1011,7 @@ def _proc_input(
     *,
     for_execution: bool,
     scratchpad: PregelScratchpad,
-    input_cache: Optional[dict[INPUT_CACHE_KEY_TYPE, Any]],
+    input_cache: dict[INPUT_CACHE_KEY_TYPE, Any] | None,
 ) -> Any:
     """Prepare input for a PULL task, based on the process's channels and triggers."""
     # if in cache return shallow copy
@@ -1018,23 +1019,20 @@ def _proc_input(
         return copy(input_cache[proc.input_cache_key])
     # If all trigger channels subscribed by this process are not empty
     # then invoke the process with the values of all non-empty channels
-    if isinstance(proc.channels, dict):
+    if isinstance(proc.channels, list):
         val: dict[str, Any] = {}
-        for k, chan in proc.channels.items():
-            if chan in channels:
-                if channels[chan].is_available():
-                    val[k] = channels[chan].get()
-            else:
-                val[k] = managed[k].get(scratchpad)
-    elif isinstance(proc.channels, list):
         for chan in proc.channels:
             if chan in channels:
                 if channels[chan].is_available():
-                    val = channels[chan].get()
-                    break
+                    val[chan] = channels[chan].get()
             else:
-                val = managed[chan].get(scratchpad)
-                break
+                val[chan] = managed[chan].get(scratchpad)
+    elif isinstance(proc.channels, str):
+        if proc.channels in channels:
+            if channels[proc.channels].is_available():
+                val = channels[proc.channels].get()
+            else:
+                return MISSING
         else:
             return MISSING
     else:
@@ -1053,7 +1051,7 @@ def _proc_input(
     return val
 
 
-def _uuid5_str(namespace: bytes, *parts: Union[str, bytes]) -> str:
+def _uuid5_str(namespace: bytes, *parts: str | bytes) -> str:
     """Generate a UUID from the SHA-1 hash of a namespace and str parts."""
 
     sha = sha1(namespace, usedforsecurity=False)
@@ -1062,7 +1060,7 @@ def _uuid5_str(namespace: bytes, *parts: Union[str, bytes]) -> str:
     return f"{hex[:8]}-{hex[8:12]}-{hex[12:16]}-{hex[16:20]}-{hex[20:32]}"
 
 
-def _xxhash_str(namespace: bytes, *parts: Union[str, bytes]) -> str:
+def _xxhash_str(namespace: bytes, *parts: str | bytes) -> str:
     """Generate a UUID from the XXH3 hash of a namespace and str parts."""
     hex = xxh3_128_hexdigest(
         namespace + b"".join(p.encode() if isinstance(p, str) else p for p in parts)
@@ -1070,7 +1068,7 @@ def _xxhash_str(namespace: bytes, *parts: Union[str, bytes]) -> str:
     return f"{hex[:8]}-{hex[8:12]}-{hex[12:16]}-{hex[16:20]}-{hex[20:32]}"
 
 
-def task_path_str(tup: Union[str, int, tuple]) -> str:
+def task_path_str(tup: str | int | tuple) -> str:
     """Generate a string representation of the task path."""
     return (
         f"~{', '.join(task_path_str(x) for x in tup)}"
@@ -1087,7 +1085,7 @@ LAZY_ATOMIC_COUNTER_LOCK = threading.Lock()
 class LazyAtomicCounter:
     __slots__ = ("_counter",)
 
-    _counter: Optional[Callable[[], int]]
+    _counter: Callable[[], int] | None
 
     def __init__(self) -> None:
         self._counter = None

libs/langgraph/langgraph/pregel/call.py

@@ -1,12 +1,14 @@
 """Utility to convert a user provided function into a Runnable with a ChannelWrite."""
 
+from __future__ import annotations
+
 import concurrent.futures
 import functools
 import inspect
 import sys
 import types
 from collections.abc import Generator, Sequence
-from typing import Any, Callable, Generic, Optional, TypeVar, cast
+from typing import Any, Callable, Generic, TypeVar, cast
 
 from langchain_core.runnables import Runnable
 from typing_extensions import ParamSpec
@@ -40,7 +42,7 @@ def _getattribute(obj: Any, name: str) -> Any:
     return obj, parent
 
 
-def _whichmodule(obj: Any, name: str) -> Optional[str]:
+def _whichmodule(obj: Any, name: str) -> str | None:
     """Find the module an object belongs to.
 
     This function differs from ``pickle.whichmodule`` in two ways:
@@ -74,7 +76,7 @@ def _whichmodule(obj: Any, name: str) -> Optional[str]:
     return None
 
 
-def identifier(obj: Any, name: Optional[str] = None) -> Optional[str]:
+def identifier(obj: Any, name: str | None = None) -> str | None:
     """Return the module and name of an object."""
     from langgraph.pregel.read import PregelNode
     from langgraph.utils.runnable import RunnableCallable, RunnableSeq
@@ -104,8 +106,8 @@ def identifier(obj: Any, name: Optional[str] = None) -> Optional[str]:
 
 
 def _lookup_module_and_qualname(
-    obj: Any, name: Optional[str] = None
-) -> Optional[tuple[types.ModuleType, str]]:
+    obj: Any, name: str | None = None
+) -> tuple[types.ModuleType, str] | None:
     if name is None:
         name = getattr(obj, "__qualname__", None)
     if name is None:  # pragma: no cover
@@ -251,8 +253,8 @@ class SyncAsyncFuture(Generic[T], concurrent.futures.Future[T]):
 def call(
     func: Callable[P, T],
     *args: Any,
-    retry: Optional[Sequence[RetryPolicy]] = None,
-    cache_policy: Optional[CachePolicy] = None,
+    retry_policy: Sequence[RetryPolicy] | None = None,
+    cache_policy: CachePolicy | None = None,
     **kwargs: Any,
 ) -> SyncAsyncFuture[T]:
     config = get_config()
@@ -260,7 +262,7 @@ def call(
     fut = impl(
         func,
         (args, kwargs),
-        retry=retry,
+        retry_policy=retry_policy,
         cache_policy=cache_policy,
         callbacks=config["callbacks"],
     )

libs/langgraph/langgraph/pregel/checkpoint.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from datetime import datetime, timezone
-from typing import Optional, Union
 
 from langgraph.channels.base import BaseChannel
 from langgraph.checkpoint.base import Checkpoint
@@ -24,10 +25,10 @@ def empty_checkpoint() -> Checkpoint:
 
 def create_checkpoint(
     checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, BaseChannel]],
+    channels: Mapping[str, BaseChannel] | None,
     step: int,
     *,
-    id: Optional[str] = None,
+    id: str | None = None,
 ) -> Checkpoint:
     """Create a checkpoint for the given channels."""
     ts = datetime.now(timezone.utc).isoformat()
@@ -52,7 +53,7 @@ def create_checkpoint(
 
 
 def channels_from_checkpoint(
-    specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]],
+    specs: Mapping[str, BaseChannel | ManagedValueSpec],
     checkpoint: Checkpoint,
 ) -> tuple[Mapping[str, BaseChannel], ManagedValueMapping]:
     """Get channels from a checkpoint."""

libs/langgraph/langgraph/pregel/debug.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Mapping, Sequence
 from dataclasses import asdict
@@ -6,7 +8,6 @@ from pprint import pformat
 from typing import (
     Any,
     Literal,
-    Optional,
     Union,
 )
 from uuid import UUID
@@ -43,7 +44,7 @@ class TaskPayload(TypedDict):
 class TaskResultPayload(TypedDict):
     id: str
     name: str
-    error: Optional[str]
+    error: str | None
     interrupts: list[dict]
     result: list[tuple[str, Any]]
 
@@ -51,17 +52,17 @@ class TaskResultPayload(TypedDict):
 class CheckpointTask(TypedDict):
     id: str
     name: str
-    error: Optional[str]
+    error: str | None
     interrupts: list[dict]
-    state: Optional[RunnableConfig]
+    state: RunnableConfig | None
 
 
 class CheckpointPayload(TypedDict):
-    config: Optional[RunnableConfig]
+    config: RunnableConfig | None
     metadata: CheckpointMetadata
     values: dict[str, Any]
     next: list[str]
-    parent_config: Optional[RunnableConfig]
+    parent_config: RunnableConfig | None
     tasks: list[CheckpointTask]
 
 
@@ -116,7 +117,7 @@ def map_debug_tasks(
 def map_debug_task_results(
     step: int,
     task_tup: tuple[PregelExecutableTask, Sequence[tuple[str, Any]]],
-    stream_keys: Union[str, Sequence[str]],
+    stream_keys: str | Sequence[str],
 ) -> Iterator[DebugOutputTaskResult]:
     """Produce "task_result" events for stream_mode=debug."""
     stream_channels_list = (
@@ -144,7 +145,7 @@ def map_debug_task_results(
     }
 
 
-def rm_pregel_keys(config: Optional[RunnableConfig]) -> Optional[RunnableConfig]:
+def rm_pregel_keys(config: RunnableConfig | None) -> RunnableConfig | None:
     """Remove pregel-specific keys from the config."""
     if config is None:
         return config
@@ -161,18 +162,18 @@ def map_debug_checkpoint(
     step: int,
     config: RunnableConfig,
     channels: Mapping[str, BaseChannel],
-    stream_channels: Union[str, Sequence[str]],
+    stream_channels: str | Sequence[str],
     metadata: CheckpointMetadata,
     checkpoint: Checkpoint,
     tasks: Iterable[PregelExecutableTask],
     pending_writes: list[PendingWrite],
-    parent_config: Optional[RunnableConfig],
-    output_keys: Union[str, Sequence[str]],
+    parent_config: RunnableConfig | None,
+    output_keys: str | Sequence[str],
 ) -> Iterator[DebugOutputCheckpoint]:
     """Produce "checkpoint" events for stream_mode=debug."""
 
     parent_ns = config[CONF].get(CONFIG_KEY_CHECKPOINT_NS, "")
-    task_states: dict[str, Union[RunnableConfig, StateSnapshot]] = {}
+    task_states: dict[str, RunnableConfig | StateSnapshot] = {}
 
     for task in tasks:
         if not task.subgraphs:
@@ -278,10 +279,10 @@ def print_step_checkpoint(
 
 
 def tasks_w_writes(
-    tasks: Iterable[Union[PregelTask, PregelExecutableTask]],
-    pending_writes: Optional[list[PendingWrite]],
-    states: Optional[dict[str, Union[RunnableConfig, StateSnapshot]]],
-    output_keys: Union[str, Sequence[str]],
+    tasks: Iterable[PregelTask | PregelExecutableTask],
+    pending_writes: list[PendingWrite] | None,
+    states: dict[str, RunnableConfig | StateSnapshot] | None,
+    output_keys: str | Sequence[str],
 ) -> tuple[PregelTask, ...]:
     """Apply writes / subgraph states to tasks to be returned in a StateSnapshot."""
     pending_writes = pending_writes or []

libs/langgraph/langgraph/pregel/draw.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections import defaultdict
 from collections.abc import Mapping, Sequence
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.runnables.graph import Graph, Node
@@ -26,10 +28,10 @@ def draw_graph(
     config: RunnableConfig,
     *,
     nodes: dict[str, PregelNode],
-    specs: dict[str, Union[BaseChannel, ManagedValueSpec]],
-    input_channels: Union[str, Sequence[str]],
-    interrupt_after_nodes: Union[All, Sequence[str]],
-    interrupt_before_nodes: Union[All, Sequence[str]],
+    specs: dict[str, BaseChannel | ManagedValueSpec],
+    input_channels: str | Sequence[str],
+    interrupt_after_nodes: All | Sequence[str],
+    interrupt_before_nodes: All | Sequence[str],
     trigger_to_nodes: Mapping[str, Sequence[str]],
     checkpointer: Checkpointer,
     subgraphs: dict[str, Graph],
@@ -46,7 +48,7 @@ def draw_graph(
         The graph for this Pregel instance.
     """
     # (src, dest, is_conditional, label)
-    edges: set[tuple[str, str, bool, Optional[str]]] = set()
+    edges: set[tuple[str, str, bool, str | None]] = set()
 
     step = -1
     checkpoint = empty_checkpoint()
@@ -60,8 +62,8 @@ def draw_graph(
         checkpoint,
     )
     static_seen: set[Any] = set()
-    sources: dict[str, set[tuple[str, bool, Optional[str]]]] = {}
-    step_sources: dict[str, set[tuple[str, bool, Optional[str]]]] = {}
+    sources: dict[str, set[tuple[str, bool, str | None]]] = {}
+    step_sources: dict[str, set[tuple[str, bool, str | None]]] = {}
     # remove node mappers
     nodes = {
         k: v.copy(update={"mapper": None}) if v.mapper is not None else v
@@ -100,7 +102,7 @@ def draw_graph(
     for step in range(step, limit):
         if not tasks:
             break
-        conditionals: dict[tuple[str, str, Any], Optional[str]] = {}
+        conditionals: dict[tuple[str, str, Any], str | None] = {}
         # run task writers
         for task in tasks.values():
             for w in task.writers:
@@ -140,8 +142,8 @@ def draw_graph(
         }
         sources.update(step_sources)
         # invert triggers
-        trigger_to_sources: dict[str, set[tuple[str, bool, Optional[str]]]] = (
-            defaultdict(set)
+        trigger_to_sources: dict[str, set[tuple[str, bool, str | None]]] = defaultdict(
+            set
         )
         for src, triggers in sources.items():
             for trigger, cond, label in triggers:
@@ -246,7 +248,7 @@ def add_edge(
     source: str,
     target: str,
     *,
-    data: Optional[Any] = None,
+    data: Any | None = None,
     conditional: bool = False,
 ) -> None:
     """Add an edge to the graph."""

libs/langgraph/langgraph/pregel/executor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import concurrent.futures
 import time
@@ -7,7 +9,6 @@ from contextvars import copy_context
 from types import TracebackType
 from typing import (
     Callable,
-    Optional,
     Protocol,
     TypeVar,
     cast,
@@ -29,7 +30,7 @@ class Submit(Protocol[P, T]):
         self,
         fn: Callable[P, T],
         *args: P.args,
-        __name__: Optional[str] = None,
+        __name__: str | None = None,
         __cancel_on_exit__: bool = False,
         __reraise_on_exit__: bool = True,
         __next_tick__: bool = False,
@@ -55,7 +56,7 @@ class BackgroundExecutor(AbstractContextManager):
         self,
         fn: Callable[P, T],
         *args: P.args,
-        __name__: Optional[str] = None,  # currently not used in sync version
+        __name__: str | None = None,  # currently not used in sync version
         __cancel_on_exit__: bool = False,  # for sync, can cancel only if not started
         __reraise_on_exit__: bool = True,
         __next_tick__: bool = False,
@@ -92,10 +93,10 @@ class BackgroundExecutor(AbstractContextManager):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
         # copy the tasks as done() callback may modify the dict
         tasks = self.tasks.copy()
         # cancel all tasks that should be cancelled
@@ -133,7 +134,7 @@ class AsyncBackgroundExecutor(AbstractAsyncContextManager):
         self.sentinel = object()
         self.loop = asyncio.get_running_loop()
         if max_concurrency := config.get("max_concurrency"):
-            self.semaphore: Optional[asyncio.Semaphore] = asyncio.Semaphore(
+            self.semaphore: asyncio.Semaphore | None = asyncio.Semaphore(
                 max_concurrency
             )
         else:
@@ -143,7 +144,7 @@ class AsyncBackgroundExecutor(AbstractAsyncContextManager):
         self,
         fn: Callable[P, Awaitable[T]],
         *args: P.args,
-        __name__: Optional[str] = None,
+        __name__: str | None = None,
         __cancel_on_exit__: bool = False,
         __reraise_on_exit__: bool = True,
         __next_tick__: bool = False,  # noop in async (always True)
@@ -185,9 +186,9 @@ class AsyncBackgroundExecutor(AbstractAsyncContextManager):
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         # copy the tasks as done() callback may modify the dict
         tasks = self.tasks.copy()

libs/langgraph/langgraph/pregel/io.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections import Counter
 from collections.abc import Iterator, Mapping, Sequence
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from langgraph.channels.base import BaseChannel, EmptyChannelError
 from langgraph.constants import (
@@ -37,10 +39,10 @@ def read_channel(
 
 def read_channels(
     channels: Mapping[str, BaseChannel],
-    select: Union[Sequence[str], str],
+    select: Sequence[str] | str,
     *,
     skip_empty: bool = True,
-) -> Union[dict[str, Any], Any]:
+) -> dict[str, Any] | Any:
     if isinstance(select, str):
         return read_channel(channels, select)
     else:
@@ -79,8 +81,8 @@ def map_command(cmd: Command) -> Iterator[tuple[str, str, Any]]:
 
 
 def map_input(
-    input_channels: Union[str, Sequence[str]],
-    chunk: Optional[Union[dict[str, Any], Any]],
+    input_channels: str | Sequence[str],
+    chunk: dict[str, Any] | Any | None,
 ) -> Iterator[tuple[str, Any]]:
     """Map input chunk to a sequence of pending writes in the form (channel, value)."""
     if chunk is None:
@@ -98,10 +100,10 @@ def map_input(
 
 
 def map_output_values(
-    output_channels: Union[str, Sequence[str]],
-    pending_writes: Union[Literal[True], Sequence[tuple[str, Any]]],
+    output_channels: str | Sequence[str],
+    pending_writes: Literal[True] | Sequence[tuple[str, Any]],
     channels: Mapping[str, BaseChannel],
-) -> Iterator[Union[dict[str, Any], Any]]:
+) -> Iterator[dict[str, Any] | Any]:
     """Map pending writes (a sequence of tuples (channel, value)) to output chunk."""
     if isinstance(output_channels, str):
         if pending_writes is True or any(
@@ -116,10 +118,10 @@ def map_output_values(
 
 
 def map_output_updates(
-    output_channels: Union[str, Sequence[str]],
+    output_channels: str | Sequence[str],
     tasks: list[tuple[PregelExecutableTask, Sequence[tuple[str, Any]]]],
     cached: bool = False,
-) -> Iterator[dict[str, Union[Any, dict[str, Any]]]]:
+) -> Iterator[dict[str, Any | dict[str, Any]]]:
     """Map pending writes (a sequence of tuples (channel, value)) to output chunk."""
     output_tasks = [
         (t, ww)

libs/langgraph/langgraph/pregel/loop.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import asyncio
 import binascii
 import concurrent.futures
-import dataclasses
 from collections import defaultdict, deque
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import (
@@ -18,13 +19,11 @@ from typing import (
     Literal,
     Optional,
     TypeVar,
-    Union,
     cast,
 )
 
 from langchain_core.callbacks import AsyncParentRunManager, ParentRunManager
 from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel
 from typing_extensions import ParamSpec, Self
 
 from langgraph.cache.base import BaseCache
@@ -45,9 +44,6 @@ from langgraph.constants import (
     CONFIG_KEY_CHECKPOINT_ID,
     CONFIG_KEY_CHECKPOINT_MAP,
     CONFIG_KEY_CHECKPOINT_NS,
-    CONFIG_KEY_DEDUPE_TASKS,
-    CONFIG_KEY_DELEGATE,
-    CONFIG_KEY_ENSURE_LATEST,
     CONFIG_KEY_RESUME_MAP,
     CONFIG_KEY_RESUMING,
     CONFIG_KEY_SCRATCHPAD,
@@ -59,17 +55,15 @@ from langgraph.constants import (
     INPUT,
     INTERRUPT,
     MISSING,
+    NS_END,
     NS_SEP,
     NULL_TASK_ID,
     PUSH,
     RESUME,
-    SCHEDULED,
     TAG_HIDDEN,
 )
 from langgraph.errors import (
-    CheckpointNotLatest,
     EmptyInputError,
-    GraphDelegate,
     GraphInterrupt,
 )
 from langgraph.managed.base import (
@@ -131,9 +125,7 @@ from langgraph.utils.config import patch_configurable
 V = TypeVar("V")
 P = ParamSpec("P")
 
-INPUT_DONE = object()
-INPUT_RESUMING = object()
-INPUT_SHOULD_VALIDATE = object()
+
 WritesT = Sequence[tuple[str, Any]]
 
 
@@ -148,36 +140,36 @@ def DuplexStream(*streams: StreamProtocol) -> StreamProtocol:
 
 class PregelLoop:
     config: RunnableConfig
-    store: Optional["BaseStore"]
-    stream: Optional[StreamProtocol]
+    store: BaseStore | None
+    stream: StreamProtocol | None
     step: int
     stop: int
 
-    input: Optional[Any]
-    input_model: Optional[type[BaseModel]]
-    cache: Optional[BaseCache[WritesT]]
-    checkpointer: Optional[BaseCheckpointSaver]
+    input: Any | None
+    cache: BaseCache[WritesT] | None
+    checkpointer: BaseCheckpointSaver | None
     nodes: Mapping[str, PregelNode]
-    specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]]
-    output_keys: Union[str, Sequence[str]]
-    stream_keys: Union[str, Sequence[str]]
+    specs: Mapping[str, BaseChannel | ManagedValueSpec]
+    input_keys: str | Sequence[str]
+    output_keys: str | Sequence[str]
+    stream_keys: str | Sequence[str]
     skip_done_tasks: bool
     is_nested: bool
-    manager: Union[None, AsyncParentRunManager, ParentRunManager]
-    interrupt_after: Union[All, Sequence[str]]
-    interrupt_before: Union[All, Sequence[str]]
+    manager: None | AsyncParentRunManager | ParentRunManager
+    interrupt_after: All | Sequence[str]
+    interrupt_before: All | Sequence[str]
     checkpoint_during: bool
     debug: bool
     retry_policy: Sequence[RetryPolicy]
-    cache_policy: Optional[CachePolicy]
+    cache_policy: CachePolicy | None
 
     checkpointer_get_next_version: GetNextVersion
-    checkpointer_put_writes: Optional[Callable[[RunnableConfig, WritesT, str], Any]]
+    checkpointer_put_writes: Callable[[RunnableConfig, WritesT, str], Any] | None
     checkpointer_put_writes_accepts_task_path: bool
-    _checkpointer_put_after_previous: Optional[
+    _checkpointer_put_after_previous: (
         Callable[
             [
-                Optional[concurrent.futures.Future],
+                concurrent.futures.Future | None,
                 RunnableConfig,
                 Checkpoint,
                 str,
@@ -185,8 +177,9 @@ class PregelLoop:
             ],
             Any,
         ]
-    ]
-    _migrate_checkpoint: Optional[Callable[[Checkpoint], None]]
+        | None
+    )
+    _migrate_checkpoint: Callable[[Checkpoint], None] | None
     submit: Submit
     channels: Mapping[str, BaseChannel]
     managed: ManagedValueMapping
@@ -196,40 +189,45 @@ class PregelLoop:
     checkpoint_config: RunnableConfig
     checkpoint_metadata: CheckpointMetadata
     checkpoint_pending_writes: list[PendingWrite]
-    checkpoint_previous_versions: dict[str, Union[str, float, int]]
-    prev_checkpoint_config: Optional[RunnableConfig]
+    checkpoint_previous_versions: dict[str, str | float | int]
+    prev_checkpoint_config: RunnableConfig | None
 
     status: Literal[
-        "pending", "done", "interrupt_before", "interrupt_after", "out_of_steps"
+        "input",
+        "pending",
+        "done",
+        "interrupt_before",
+        "interrupt_after",
+        "out_of_steps",
     ]
     tasks: dict[str, PregelExecutableTask]
-    to_interrupt: list[PregelExecutableTask]
-    output: Union[None, dict[str, Any], Any] = None
+    output: None | dict[str, Any] | Any = None
+    updated_channels: set[str] | None = None
 
     # public
 
     def __init__(
         self,
-        input: Optional[Any],
+        input: Any | None,
         *,
-        stream: Optional[StreamProtocol],
+        stream: StreamProtocol | None,
         config: RunnableConfig,
-        store: Optional[BaseStore],
-        cache: Optional[BaseCache],
-        checkpointer: Optional[BaseCheckpointSaver],
+        store: BaseStore | None,
+        cache: BaseCache | None,
+        checkpointer: BaseCheckpointSaver | None,
         nodes: Mapping[str, PregelNode],
-        specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]],
-        output_keys: Union[str, Sequence[str]],
-        stream_keys: Union[str, Sequence[str]],
+        specs: Mapping[str, BaseChannel | ManagedValueSpec],
+        input_keys: str | Sequence[str],
+        output_keys: str | Sequence[str],
+        stream_keys: str | Sequence[str],
         trigger_to_nodes: Mapping[str, Sequence[str]],
-        interrupt_after: Union[All, Sequence[str]] = EMPTY_SEQ,
-        interrupt_before: Union[All, Sequence[str]] = EMPTY_SEQ,
-        manager: Union[None, AsyncParentRunManager, ParentRunManager] = None,
-        input_model: Optional[type[BaseModel]] = None,
+        interrupt_after: All | Sequence[str] = EMPTY_SEQ,
+        interrupt_before: All | Sequence[str] = EMPTY_SEQ,
+        manager: None | AsyncParentRunManager | ParentRunManager = None,
         debug: bool = False,
-        migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
+        migrate_checkpoint: Callable[[Checkpoint], None] | None = None,
         retry_policy: Sequence[RetryPolicy] = (),
-        cache_policy: Optional[CachePolicy] = None,
+        cache_policy: CachePolicy | None = None,
         checkpoint_during: bool = True,
     ) -> None:
         self.stream = stream
@@ -238,21 +236,18 @@ class PregelLoop:
         self.step = 0
         self.stop = 0
         self.input = input
-        self.input_model = input_model
         self.checkpointer = checkpointer
         self.cache = cache
         self.nodes = nodes
         self.specs = specs
+        self.input_keys = input_keys
         self.output_keys = output_keys
         self.stream_keys = stream_keys
         self.interrupt_after = interrupt_after
         self.interrupt_before = interrupt_before
         self.manager = manager
         self.is_nested = CONFIG_KEY_TASK_ID in self.config.get(CONF, {})
-        self.skip_done_tasks = (
-            CONFIG_KEY_CHECKPOINT_ID not in config[CONF]
-            or CONFIG_KEY_DEDUPE_TASKS in config[CONF]
-        )
+        self.skip_done_tasks = CONFIG_KEY_CHECKPOINT_ID not in config[CONF]
         self._migrate_checkpoint = migrate_checkpoint
         self.trigger_to_nodes = trigger_to_nodes
         self.retry_policy = retry_policy
@@ -261,10 +256,8 @@ class PregelLoop:
         self.debug = debug
         if self.stream is not None and CONFIG_KEY_STREAM in config[CONF]:
             self.stream = DuplexStream(self.stream, config[CONF][CONFIG_KEY_STREAM])
-        scratchpad: Optional[PregelScratchpad] = config[CONF].get(CONFIG_KEY_SCRATCHPAD)
-        if not self.config[CONF].get(CONFIG_KEY_DELEGATE) and isinstance(
-            scratchpad, PregelScratchpad
-        ):
+        scratchpad: PregelScratchpad | None = config[CONF].get(CONFIG_KEY_SCRATCHPAD)
+        if isinstance(scratchpad, PregelScratchpad):
             # if count is > 0, append to checkpoint_ns
             # if count is 0, leave as is
             if cnt := scratchpad.subgraph_counter():
@@ -399,15 +392,9 @@ class PregelLoop:
                 )
 
     def accept_push(
-        self, task: PregelExecutableTask, write_idx: int, call: Optional[Call] = None
-    ) -> Optional[PregelExecutableTask]:
+        self, task: PregelExecutableTask, write_idx: int, call: Call | None = None
+    ) -> PregelExecutableTask | None:
         """Accept a PUSH from a task, potentially returning a new task to start."""
-        # don't start if we should interrupt *after* the original task
-        if self.interrupt_after and should_interrupt(
-            self.checkpoint, self.interrupt_after, [task]
-        ):
-            self.to_interrupt.append(task)
-            return
         checkpoint_id_bytes = binascii.unhexlify(self.checkpoint["id"].replace("-", ""))
         null_version = checkpoint_null_version(self.checkpoint)
         if pushed := cast(
@@ -433,12 +420,6 @@ class PregelLoop:
                 cache_policy=self.cache_policy,
             ),
         ):
-            # don't start if we should interrupt *before* the new task
-            if self.interrupt_before and should_interrupt(
-                self.checkpoint, self.interrupt_before, [pushed]
-            ):
-                self.to_interrupt.append(pushed)
-                return
             # produce debug output
             self._emit("debug", map_debug_tasks, self.step, [pushed])
             # debug flag
@@ -452,11 +433,7 @@ class PregelLoop:
             # return the new task, to be started if not run before
             return pushed
 
-    def tick(
-        self,
-        *,
-        input_keys: Union[str, Sequence[str]],
-    ) -> bool:
+    def tick(self) -> bool:
         """Execute a single iteration of the Pregel loop.
 
         Args:
@@ -465,72 +442,6 @@ class PregelLoop:
         Returns:
             True if more iterations are needed.
         """
-        if self.status != "pending":
-            raise RuntimeError("Cannot tick when status is no longer 'pending'")
-
-        updated_channels: set[str] | None = None
-
-        if self.input not in (INPUT_DONE, INPUT_RESUMING, INPUT_SHOULD_VALIDATE):
-            updated_channels = self._first(input_keys=input_keys)
-        elif self.to_interrupt:
-            # if we need to interrupt, do so
-            self.status = "interrupt_before"
-            raise GraphInterrupt()
-        elif all(task.writes for task in self.tasks.values()):
-            # finish superstep
-            writes = [w for t in self.tasks.values() for w in t.writes]
-            # debug flag
-            if self.debug:
-                print_step_writes(
-                    self.step,
-                    writes,
-                    (
-                        [self.stream_keys]
-                        if isinstance(self.stream_keys, str)
-                        else self.stream_keys
-                    ),
-                )
-            # all tasks have finished
-            updated_channels = apply_writes(
-                self.checkpoint,
-                self.channels,
-                self.tasks.values(),
-                self.checkpointer_get_next_version,
-                self.trigger_to_nodes,
-            )
-            # validate input if requested
-            if self.input is INPUT_SHOULD_VALIDATE:
-                self.input = INPUT_DONE
-                # validate
-                cast(type[BaseModel], self.input_model)(
-                    **read_channels(self.channels, self.stream_keys)
-                )
-            # produce values output
-            if not updated_channels.isdisjoint(
-                (self.output_keys,)
-                if isinstance(self.output_keys, str)
-                else self.output_keys
-            ):
-                self._emit(
-                    "values", map_output_values, self.output_keys, writes, self.channels
-                )
-            # clear pending writes
-            self.checkpoint_pending_writes.clear()
-            # "not skip_done_tasks" only applies to first tick after resuming
-            self.skip_done_tasks = True
-            # save checkpoint
-            self._put_checkpoint({"source": "loop"})
-            # after execution, check if we should interrupt
-            if self.interrupt_after and should_interrupt(
-                self.checkpoint, self.interrupt_after, self.tasks.values()
-            ):
-                self.status = "interrupt_after"
-                raise GraphInterrupt()
-
-            # unset resuming flag
-            self.config[CONF].pop(CONFIG_KEY_RESUMING, None)
-        else:
-            return False
 
         # check if iteration limit is reached
         if self.step > self.stop:
@@ -552,11 +463,10 @@ class PregelLoop:
             store=self.store,
             checkpointer=self.checkpointer,
             trigger_to_nodes=self.trigger_to_nodes,
-            updated_channels=updated_channels,
+            updated_channels=self.updated_channels,
             retry_policy=self.retry_policy,
             cache_policy=self.cache_policy,
         )
-        self.to_interrupt = []
 
         # produce debug output
         if self._checkpointer_put_after_previous is not None:
@@ -586,26 +496,10 @@ class PregelLoop:
             self.status = "done"
             return False
 
-        # check if we should delegate (used by subgraphs in distributed mode)
-        if self.config[CONF].get(CONFIG_KEY_DELEGATE):
-            assert self.input is INPUT_RESUMING
-            raise GraphDelegate(
-                {
-                    "config": patch_configurable(
-                        self.config, {CONFIG_KEY_DELEGATE: False}
-                    ),
-                    "input": None,
-                }
-            )
-
         # if there are pending writes from a previous loop, apply them
         if self.skip_done_tasks and self.checkpoint_pending_writes:
             self._match_writes(self.tasks)
 
-        # if all tasks have finished, re-tick
-        if all(task.writes for task in self.tasks.values()):
-            return self.tick(input_keys=input_keys)
-
         # before execution, check if we should interrupt
         if self.interrupt_before and should_interrupt(
             self.checkpoint, self.interrupt_before, self.tasks.values()
@@ -627,6 +521,52 @@ class PregelLoop:
 
         return True
 
+    def after_tick(self) -> None:
+        # finish superstep
+        writes = [w for t in self.tasks.values() for w in t.writes]
+        # debug flag
+        if self.debug:
+            print_step_writes(
+                self.step,
+                writes,
+                (
+                    [self.stream_keys]
+                    if isinstance(self.stream_keys, str)
+                    else self.stream_keys
+                ),
+            )
+        # all tasks have finished
+        self.updated_channels = apply_writes(
+            self.checkpoint,
+            self.channels,
+            self.tasks.values(),
+            self.checkpointer_get_next_version,
+            self.trigger_to_nodes,
+        )
+        # produce values output
+        if not self.updated_channels.isdisjoint(
+            (self.output_keys,)
+            if isinstance(self.output_keys, str)
+            else self.output_keys
+        ):
+            self._emit(
+                "values", map_output_values, self.output_keys, writes, self.channels
+            )
+        # clear pending writes
+        self.checkpoint_pending_writes.clear()
+        # "not skip_done_tasks" only applies to first tick after resuming
+        self.skip_done_tasks = True
+        # save checkpoint
+        self._put_checkpoint({"source": "loop"})
+        # after execution, check if we should interrupt
+        if self.interrupt_after and should_interrupt(
+            self.checkpoint, self.interrupt_after, self.tasks.values()
+        ):
+            self.status = "interrupt_after"
+            raise GraphInterrupt()
+        # unset resuming flag
+        self.config[CONF].pop(CONFIG_KEY_RESUMING, None)
+
     def match_cached_writes(self) -> Sequence[PregelExecutableTask]:
         raise NotImplementedError
 
@@ -640,16 +580,9 @@ class PregelLoop:
             if k in (ERROR, INTERRUPT, RESUME):
                 continue
             if task := tasks.get(tid):
-                if k == SCHEDULED:
-                    if v == max(
-                        self.checkpoint["versions_seen"].get(INTERRUPT, {}).values(),
-                        default=None,
-                    ):
-                        self.tasks[tid] = dataclasses.replace(task, scheduled=True)
-                else:
-                    task.writes.append((k, v))
+                task.writes.append((k, v))
 
-    def _first(self, *, input_keys: Union[str, Sequence[str]]) -> Optional[set[str]]:
+    def _first(self, *, input_keys: str | Sequence[str]) -> set[str] | None:
         # resuming from previous checkpoint requires
         # - finding a previous checkpoint
         # - receiving None input (outer graph) or RESUMING flag (subgraph)
@@ -667,7 +600,7 @@ class PregelLoop:
             )
         )
         # this can be set only when there are input_writes
-        updated_channels: Optional[set[str]] = None
+        updated_channels: set[str] | None = None
 
         # map command to writes
         if isinstance(self.input, Command):
@@ -713,21 +646,8 @@ class PregelLoop:
             self._emit(
                 "values", map_output_values, self.output_keys, True, self.channels
             )
-            # set flag
-            self.input = INPUT_RESUMING
         # map inputs to channel updates
         elif input_writes := deque(map_input(input_keys, self.input)):
-            # TODO shouldn't these writes be passed to put_writes too?
-            # check if we should delegate (used by subgraphs in distributed mode)
-            if self.config[CONF].get(CONFIG_KEY_DELEGATE):
-                raise GraphDelegate(
-                    {
-                        "config": patch_configurable(
-                            self.config, {CONFIG_KEY_DELEGATE: False}
-                        ),
-                        "input": self.input,
-                    }
-                )
             # discard any unfinished tasks from previous checkpoint
             discard_tasks = prepare_next_tasks(
                 self.checkpoint,
@@ -756,24 +676,15 @@ class PregelLoop:
             )
             # save input checkpoint
             self._put_checkpoint({"source": "input"})
-            # set flag
-            if (
-                self.input_model is not None
-                and not isinstance(self.input, self.input_model)
-                and not isinstance(self.stream_keys, str)
-            ):
-                self.input = INPUT_SHOULD_VALIDATE
-            else:
-                self.input = INPUT_DONE
         elif CONFIG_KEY_RESUMING not in configurable:
             raise EmptyInputError(f"Received no input for {input_keys}")
-        else:
-            self.input = INPUT_DONE
         # update config
         if not self.is_nested:
             self.config = patch_configurable(
                 self.config, {CONFIG_KEY_RESUMING: is_resuming}
             )
+        # set flag
+        self.status = "pending"
         return updated_channels
 
     def _put_checkpoint(self, metadata: CheckpointMetadata) -> None:
@@ -861,12 +772,19 @@ class PregelLoop:
 
     def _suppress_interrupt(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
         # persist current checkpoint and writes
-        if not self.checkpoint_during:
+        if not self.checkpoint_during and (
+            # if it's a top graph
+            not self.is_nested
+            # or a nested graph with error or interrupt
+            or exc_value is not None
+            # or a nested graph with checkpointer=True
+            or all(NS_END not in part for part in self.checkpoint_ns)
+        ):
             self._put_checkpoint(self.checkpoint_metadata)
             self._put_pending_writes()
         # suppress interrupt
@@ -977,31 +895,30 @@ class PregelLoop:
 class SyncPregelLoop(PregelLoop, AbstractContextManager):
     def __init__(
         self,
-        input: Optional[Any],
+        input: Any | None,
         *,
-        stream: Optional[StreamProtocol],
+        stream: StreamProtocol | None,
         config: RunnableConfig,
-        store: Optional[BaseStore],
-        cache: Optional[BaseCache],
-        checkpointer: Optional[BaseCheckpointSaver],
+        store: BaseStore | None,
+        cache: BaseCache | None,
+        checkpointer: BaseCheckpointSaver | None,
         nodes: Mapping[str, PregelNode],
-        specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]],
+        specs: Mapping[str, BaseChannel | ManagedValueSpec],
         trigger_to_nodes: Mapping[str, Sequence[str]],
-        manager: Union[None, AsyncParentRunManager, ParentRunManager] = None,
-        interrupt_after: Union[All, Sequence[str]] = EMPTY_SEQ,
-        interrupt_before: Union[All, Sequence[str]] = EMPTY_SEQ,
-        output_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        input_model: Optional[type[BaseModel]] = None,
+        manager: None | AsyncParentRunManager | ParentRunManager = None,
+        interrupt_after: All | Sequence[str] = EMPTY_SEQ,
+        interrupt_before: All | Sequence[str] = EMPTY_SEQ,
+        input_keys: str | Sequence[str] = EMPTY_SEQ,
+        output_keys: str | Sequence[str] = EMPTY_SEQ,
+        stream_keys: str | Sequence[str] = EMPTY_SEQ,
         debug: bool = False,
-        migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
+        migrate_checkpoint: Callable[[Checkpoint], None] | None = None,
         retry_policy: Sequence[RetryPolicy] = (),
-        cache_policy: Optional[CachePolicy] = None,
+        cache_policy: CachePolicy | None = None,
         checkpoint_during: bool = True,
     ) -> None:
         super().__init__(
             input,
-            input_model=input_model,
             stream=stream,
             config=config,
             checkpointer=checkpointer,
@@ -1009,6 +926,7 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
             store=store,
             nodes=nodes,
             specs=specs,
+            input_keys=input_keys,
             output_keys=output_keys,
             stream_keys=stream_keys,
             interrupt_after=interrupt_after,
@@ -1037,7 +955,7 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
 
     def _checkpointer_put_after_previous(
         self,
-        prev: Optional[concurrent.futures.Future],
+        prev: concurrent.futures.Future | None,
         config: RunnableConfig,
         checkpoint: Checkpoint,
         metadata: CheckpointMetadata,
@@ -1067,8 +985,8 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
         return matched
 
     def accept_push(
-        self, task: PregelExecutableTask, write_idx: int, call: Optional[Call] = None
-    ) -> Optional[PregelExecutableTask]:
+        self, task: PregelExecutableTask, write_idx: int, call: Call | None = None
+    ) -> PregelExecutableTask | None:
         if pushed := super().accept_push(task, write_idx, call):
             for task in self.match_cached_writes():
                 self.output_writes(task.id, task.writes, cached=True)
@@ -1095,25 +1013,7 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
     # context manager
 
     def __enter__(self) -> Self:
-        if self.config.get(CONF, {}).get(
-            CONFIG_KEY_ENSURE_LATEST
-        ) and self.checkpoint_config[CONF].get(CONFIG_KEY_CHECKPOINT_ID):
-            if self.checkpointer is None:
-                raise RuntimeError(
-                    "Cannot ensure latest checkpoint without checkpointer"
-                )
-            saved = self.checkpointer.get_tuple(
-                patch_configurable(
-                    self.checkpoint_config, {CONFIG_KEY_CHECKPOINT_ID: None}
-                )
-            )
-            if (
-                saved is None
-                or saved.checkpoint["id"]
-                != self.checkpoint_config[CONF][CONFIG_KEY_CHECKPOINT_ID]
-            ):
-                raise CheckpointNotLatest
-        elif self.checkpointer:
+        if self.checkpointer:
             saved = self.checkpointer.get_tuple(self.checkpoint_config)
         else:
             saved = None
@@ -1147,19 +1047,20 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
             self.specs, self.checkpoint
         )
         self.stack.push(self._suppress_interrupt)
-        self.status = "pending"
+        self.status = "input"
         self.step = self.checkpoint_metadata["step"] + 1
         self.stop = self.step + self.config["recursion_limit"] + 1
         self.checkpoint_previous_versions = self.checkpoint["channel_versions"].copy()
+        self.updated_channels = self._first(input_keys=self.input_keys)
 
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
         # unwind stack
         return self.stack.__exit__(exc_type, exc_value, traceback)
 
@@ -1167,31 +1068,30 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
 class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
     def __init__(
         self,
-        input: Optional[Any],
+        input: Any | None,
         *,
-        stream: Optional[StreamProtocol],
+        stream: StreamProtocol | None,
         config: RunnableConfig,
-        store: Optional[BaseStore],
-        cache: Optional[BaseCache],
-        checkpointer: Optional[BaseCheckpointSaver],
+        store: BaseStore | None,
+        cache: BaseCache | None,
+        checkpointer: BaseCheckpointSaver | None,
         nodes: Mapping[str, PregelNode],
-        specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]],
+        specs: Mapping[str, BaseChannel | ManagedValueSpec],
         trigger_to_nodes: Mapping[str, Sequence[str]],
-        interrupt_after: Union[All, Sequence[str]] = EMPTY_SEQ,
-        interrupt_before: Union[All, Sequence[str]] = EMPTY_SEQ,
-        manager: Union[None, AsyncParentRunManager, ParentRunManager] = None,
-        output_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        input_model: Optional[type[BaseModel]] = None,
+        interrupt_after: All | Sequence[str] = EMPTY_SEQ,
+        interrupt_before: All | Sequence[str] = EMPTY_SEQ,
+        manager: None | AsyncParentRunManager | ParentRunManager = None,
+        input_keys: str | Sequence[str] = EMPTY_SEQ,
+        output_keys: str | Sequence[str] = EMPTY_SEQ,
+        stream_keys: str | Sequence[str] = EMPTY_SEQ,
         debug: bool = False,
-        migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
+        migrate_checkpoint: Callable[[Checkpoint], None] | None = None,
         retry_policy: Sequence[RetryPolicy] = (),
-        cache_policy: Optional[CachePolicy] = None,
+        cache_policy: CachePolicy | None = None,
         checkpoint_during: bool = True,
     ) -> None:
         super().__init__(
             input,
-            input_model=input_model,
             stream=stream,
             config=config,
             checkpointer=checkpointer,
@@ -1199,6 +1099,7 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
             store=store,
             nodes=nodes,
             specs=specs,
+            input_keys=input_keys,
             output_keys=output_keys,
             stream_keys=stream_keys,
             interrupt_after=interrupt_after,
@@ -1227,7 +1128,7 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
 
     async def _checkpointer_put_after_previous(
         self,
-        prev: Optional[asyncio.Task],
+        prev: asyncio.Task | None,
         config: RunnableConfig,
         checkpoint: Checkpoint,
         metadata: CheckpointMetadata,
@@ -1257,8 +1158,8 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
         return matched
 
     async def aaccept_push(
-        self, task: PregelExecutableTask, write_idx: int, call: Optional[Call] = None
-    ) -> Optional[PregelExecutableTask]:
+        self, task: PregelExecutableTask, write_idx: int, call: Call | None = None
+    ) -> PregelExecutableTask | None:
         if pushed := super().accept_push(task, write_idx, call):
             for task in await self.amatch_cached_writes():
                 self.output_writes(task.id, task.writes, cached=True)
@@ -1288,25 +1189,7 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
     # context manager
 
     async def __aenter__(self) -> Self:
-        if self.config.get(CONF, {}).get(
-            CONFIG_KEY_ENSURE_LATEST
-        ) and self.checkpoint_config[CONF].get(CONFIG_KEY_CHECKPOINT_ID):
-            if self.checkpointer is None:
-                raise RuntimeError(
-                    "Cannot ensure latest checkpoint without checkpointer"
-                )
-            saved = await self.checkpointer.aget_tuple(
-                patch_configurable(
-                    self.checkpoint_config, {CONFIG_KEY_CHECKPOINT_ID: None}
-                )
-            )
-            if (
-                saved is None
-                or saved.checkpoint["id"]
-                != self.checkpoint_config[CONF][CONFIG_KEY_CHECKPOINT_ID]
-            ):
-                raise CheckpointNotLatest
-        elif self.checkpointer:
+        if self.checkpointer:
             saved = await self.checkpointer.aget_tuple(self.checkpoint_config)
         else:
             saved = None
@@ -1342,20 +1225,20 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
             self.specs, self.checkpoint
         )
         self.stack.push(self._suppress_interrupt)
-        self.status = "pending"
+        self.status = "input"
         self.step = self.checkpoint_metadata["step"] + 1
         self.stop = self.step + self.config["recursion_limit"] + 1
-
         self.checkpoint_previous_versions = self.checkpoint["channel_versions"].copy()
+        self.updated_channels = self._first(input_keys=self.input_keys)
 
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
         # unwind stack
         exit_task = asyncio.create_task(
             self.stack.__aexit__(exc_type, exc_value, traceback)

libs/langgraph/langgraph/pregel/messages.py

@@ -1,10 +1,10 @@
+from __future__ import annotations
+
 from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (
     Any,
     Callable,
-    Optional,
     TypeVar,
-    Union,
     cast,
 )
 from uuid import UUID, uuid4
@@ -36,7 +36,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         self.stream = stream
         self.subgraphs = subgraphs
         self.metadata: dict[UUID, Meta] = {}
-        self.seen: set[Union[int, str]] = set()
+        self.seen: set[int | str] = set()
 
     def _emit(self, meta: Meta, message: BaseMessage, *, dedupe: bool = False) -> None:
         if dedupe and message.id in self.seen:
@@ -89,9 +89,9 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Any:
         if metadata and (
@@ -111,10 +111,10 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         self,
         token: str,
         *,
-        chunk: Optional[ChatGenerationChunk] = None,
+        chunk: ChatGenerationChunk | None = None,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
         **kwargs: Any,
     ) -> Any:
         if not isinstance(chunk, ChatGenerationChunk):
@@ -127,7 +127,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         response: LLMResult,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> Any:
         if meta := self.metadata.get(run_id):
@@ -142,7 +142,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         error: BaseException,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> Any:
         self.metadata.pop(run_id, None)
@@ -153,9 +153,9 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         inputs: dict[str, Any],
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Any:
         if (
@@ -185,7 +185,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         response: Any,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> Any:
         if meta := self.metadata.pop(run_id, None):
@@ -210,7 +210,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         error: BaseException,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> Any:
         self.metadata.pop(run_id, None)