Update

.github/workflows/_lint.yml

@@ -54,7 +54,7 @@ jobs:
         if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry check --lock
+        run: poetry lock --check
 
       - name: Install dependencies
         if: steps.changed-files.outputs.all

.github/workflows/_test.yml

@@ -39,12 +39,6 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
-      - name: Check Lock
-        shell: bash
-        working-directory: ${{ inputs.working-directory }}
-        run: |
-          poetry check --lock
-
       - name: Install dependencies
         shell: bash
         working-directory: ${{ inputs.working-directory }}

.github/workflows/deploy_docs.yml

@@ -102,14 +102,7 @@ jobs:
       - name: Build llms-text
         run: make llms-text
       - name: Build site
-        run: |
-          # If this is main branch, then we want to download stats. we do this 
-          # with the env variable DOWNLOAD_STATS=true
-          if [ "${{ github.ref }}" == "refs/heads/main" ]; then
-            DOWNLOAD_STATS=true make build-docs
-          else
-            make build-docs
-          fi
+        run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
           OPENAI_API_KEY: sf-proj-1234567890 # fake placeholder, shouldn't actually be used
@@ -134,7 +127,6 @@ jobs:
               --check-links-ignore "https://openai\.com/.*" \
               --check-links-ignore "https://www\.uber\.com/.*" \
               --check-links-ignore "https://pepy\.tech/.*" \
-              --check-links-ignore "docs/docs/static/wordmark_*" \
               --check-links $(find site -name "index.html" | grep -v 'storm/index.html')
               
           else
@@ -155,7 +147,6 @@ jobs:
                 --check-links-ignore "https://twitter.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \
-                --check-links-ignore "docs/docs/static/wordmark_*" \
                 --check-links ${CHANGED_FILES} \
                 || ([ $? = 5 ] && exit 0 || exit $?)
             else

.github/workflows/size.yml

@@ -0,0 +1,29 @@
+name: Check File Size
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  file-size-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v44
+      - name: Filter by size
+        # TODO: roll back the web voyager hack
+        run: |
+          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M | grep -v "web_voyager" || true)
+          if [ -n "$large_added_files" ]; then
+            echo "Large files added: $large_added_files"
+            echo "# Large files added:" >> $GITHUB_STEP_SUMMARY
+            echo "$large_added_files" >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi

README.md

@@ -1,87 +1,339 @@
-<picture class="github-only">
-  <source media="(prefers-color-scheme: light)" srcset="docs/docs/static/wordmark_dark.svg">
-  <source media="(prefers-color-scheme: dark)" srcset="docs/docs/static/wordmark_light.svg">
-  <img alt="LangGraph Logo" src="docs/docs/static/wordmark_dark.svg" width="80%">
-</picture>
+# 🦜🕸️LangGraph
 
-<div>
-<br>
-</div>
-
-[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/langgraph/)
+![Version](https://img.shields.io/pypi/v/langgraph)
 [![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/)
 
+⚡ Building language agents as graphs ⚡
+
 > [!NOTE]
 > Looking for the JS version? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://langchain-ai.github.io/langgraphjs/).
 
-LangGraph — used by Replit, Uber, LinkedIn, GitLab and more — is a low-level orchestration framework for building controllable agents. While langchain provides integrations and composable components to streamline LLM application development, the LangGraph library enables agent orchestration — offering customizable architectures, long-term memory, and human-in-the-loop to reliably handle complex tasks.
+## Overview
 
-```bash
+[LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building
+stateful, multi-actor applications with LLMs, used to create agent and multi-agent
+workflows. Check out an introductory tutorial [here](https://langchain-ai.github.io/langgraph/tutorials/introduction/).
+
+
+LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+
+### Why use LangGraph?
+
+LangGraph powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
+
+- **Memory**: LangGraph persists arbitrary aspects of your application's state,
+supporting memory of conversations and other updates within and across user
+interactions;
+- **Human-in-the-loop**: Because state is checkpointed, execution can be interrupted
+and resumed, allowing for decisions, validation, and corrections at key stages via
+human input.
+
+Standardizing these components allows individuals and teams to focus on the behavior
+of their agent, instead of its supporting infrastructure.
+
+Through [LangGraph Platform](#langgraph-platform), LangGraph also provides tooling for
+the development, deployment, debugging, and monitoring of your applications.
+
+LangGraph integrates seamlessly with
+[LangChain](https://python.langchain.com/docs/introduction/) and
+[LangSmith](https://docs.smith.langchain.com/) (but does not require them).
+
+To learn more about LangGraph, check out our first LangChain Academy
+course, *Introduction to LangGraph*, available for free
+[here](https://academy.langchain.com/courses/intro-to-langgraph).
+
+### LangGraph Platform
+
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger).
+
+See deployment options [here](https://langchain-ai.github.io/langgraph/concepts/deployment_options/)
+(includes a free tier).
+
+Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+
+- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
+- **Background runs**: Runs agents asynchronously in the background
+- **Support for long running agents**: Infrastructure that can handle long running processes
+- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
+- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
+
+## Installation
+
+```shell
 pip install -U langgraph
 ```
 
-To learn more about how to use LangGraph, check out [the docs](https://langchain-ai.github.io/langgraph/). We show a simple example below of how to create a ReAct agent.
+## Example
+
+Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
+
+```shell
+pip install langchain-anthropic
+```
+
+```shell
+export ANTHROPIC_API_KEY=sk-...
+```
+
+Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
+
+```shell
+export LANGSMITH_TRACING=true
+export LANGSMITH_API_KEY=lsv2_sk_...
+```
+
+The simplest way to create a tool-calling agent in LangGraph is to use `create_react_agent`:
+
+<details open>
+  <summary>High-level implementation</summary>
 
 ```python
-# This code depends on pip install langchain[anthropic]
 from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
 
+# Define the tools for the agent to use
+@tool
 def search(query: str):
     """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
     if "sf" in query.lower() or "san francisco" in query.lower():
         return "It's 60 degrees and foggy."
     return "It's 90 degrees and sunny."
 
-agent = create_react_agent("anthropic:claude-3-7-sonnet-latest", tools=[search])
-agent.invoke(
-    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
+
+tools = [search]
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
 )
+final_state["messages"][-1].content
+```
+```
+"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
 ```
 
-## Why use LangGraph?
+Now when we pass the same <code>"thread_id"</code>, the conversation context is retained via the saved state (i.e. stored list of messages)
 
-LangGraph is built for developers who want to build powerful, adaptable AI agents. Developers choose LangGraph for:
+```python
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what about ny"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
 
-- **Reliability and controllability.** Steer agent actions with moderation checks and human-in-the-loop approvals. LangGraph persists context for long-running workflows, keeping your agents on course.
-- **Low-level and extensible.** Build custom agents with fully descriptive, low-level primitives – free from rigid abstractions that limit customization. Design scalable multi-agent systems, with each agent serving a specific role tailored to your use case.
-- **First-class streaming support.** With token-by-token streaming and streaming of intermediate steps, LangGraph gives users clear visibility into agent reasoning and actions as they unfold in real time.
+```
+"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
+```
+</details>
 
-LangGraph is trusted in production and powering agents for companies like:
+> [!TIP]
+> LangGraph is a **low-level** framework that allows you to implement any custom agent
+architectures. Click on the low-level implementation below to see how to implement a
+tool-calling agent from scratch.
 
-- [Klarna](https://blog.langchain.dev/customers-klarna/): Customer support bot for 85 million active users
-- [Elastic](https://www.elastic.co/blog/elastic-security-generative-ai-features): Security AI assistant for threat detection
-- [Uber](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/): Automated unit test generation
-- [Replit](https://www.langchain.com/breakoutagents/replit): Code generation
-- And many more ([see list here](https://www.langchain.com/built-with-langgraph))
+<details>
+<summary>Low-level implementation</summary>
 
-## LangGraph’s ecosystem
+```python
+from typing import Literal
 
-While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode
 
-- [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
-- [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/).
 
-## Pairing with LangGraph Platform
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
 
-While LangGraph is our open-source agent orchestration framework, enterprises that need scalable agent deployment can benefit from [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/).
 
-LangGraph Platform can help engineering teams:
+tools = [search]
 
-- **Accelerate agent development**: Quickly create agent UXs with configurable templates and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/) for visualizing and debugging agent interactions.
-- **Deploy seamlessly**: We handle the complexity of deploying your agent. LangGraph Platform includes robust APIs for memory, threads, and cron jobs plus auto-scaling task queues & servers.
-- **Centralize agent management & reusability**: Discover, reuse, and manage agents across the organization. Business users can also modify agents without coding.
+tool_node = ToolNode(tools)
 
-## Additional resources
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0).bind_tools(tools)
 
-- [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
-- [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Simple walkthroughs with guided examples on getting started with LangGraph.
-- [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
-- [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
-- [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
-- [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
+# Define the function that determines whether to continue or not
+def should_continue(state: MessagesState) -> Literal["tools", END]:
+    messages = state['messages']
+    last_message = messages[-1]
+    # If the LLM makes a tool call, then we route to the "tools" node
+    if last_message.tool_calls:
+        return "tools"
+    # Otherwise, we stop (reply to the user)
+    return END
 
-## Acknowledgements
 
-LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+# Define the function that calls the model
+def call_model(state: MessagesState):
+    messages = state['messages']
+    response = model.invoke(messages)
+    # We return a list, because this will get added to the existing list
+    return {"messages": [response]}
+
+
+# Define a new graph
+workflow = StateGraph(MessagesState)
+
+# Define the two nodes we will cycle between
+workflow.add_node("agent", call_model)
+workflow.add_node("tools", tool_node)
+
+# Set the entrypoint as `agent`
+# This means that this node is the first one called
+workflow.add_edge(START, "agent")
+
+# We now add a conditional edge
+workflow.add_conditional_edges(
+    # First, we define the start node. We use `agent`.
+    # This means these are the edges taken after the `agent` node is called.
+    "agent",
+    # Next, we pass in the function that will determine which node is called next.
+    should_continue,
+)
+
+# We now add a normal edge from `tools` to `agent`.
+# This means that after `tools` is called, `agent` node is called next.
+workflow.add_edge("tools", 'agent')
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+# Finally, we compile it!
+# This compiles it into a LangChain Runnable,
+# meaning you can use it as you would any other runnable.
+# Note that we're (optionally) passing the memory when compiling the graph
+app = workflow.compile(checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+
+<b>Step-by-step Breakdown</b>:
+
+<details>
+<summary>Initialize the model and tools.</summary>
+<ul>
+  <li>
+    We use <code>ChatAnthropic</code> as our LLM. <strong>NOTE:</strong> we need to make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the <code>.bind_tools()</code> method.
+  </li>
+  <li>
+    We define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that <a href="https://python.langchain.com/docs/how_to/custom_tools/">here</a>.
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Initialize graph with state.</summary>
+
+<ul>
+    <li>We initialize graph (<code>StateGraph</code>) by passing state schema (in our case <code>MessagesState</code>)</li>
+    <li><code>MessagesState</code> is a prebuilt state schema that has one attribute -- a list of LangChain <code>Message</code> objects, as well as logic for merging the updates from each node into the state.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define graph nodes.</summary>
+
+There are two main nodes we need:
+
+<ul>
+    <li>The <code>agent</code> node: responsible for deciding what (if any) actions to take.</li>
+    <li>The <code>tools</code> node that invokes tools: if the agent decides to take an action, this node will then execute that action.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define entry point and graph edges.</summary>
+
+First, we need to set the entry point for graph execution - <code>agent</code> node.
+
+Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (<code>MessagesState</code>). In our case, the destination is not known until the agent (LLM) decides.
+
+<ul>
+  <li>Conditional edge: after the agent is called, we should either:
+    <ul>
+      <li>a. Run tools if the agent said to take an action, OR</li>
+      <li>b. Finish (respond to the user) if the agent did not ask to run tools</li>
+    </ul>
+  </li>
+  <li>Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next</li>
+</ul>
+</details>
+
+<details>
+<summary>Compile the graph.</summary>
+
+<ul>
+  <li>
+    When we compile the graph, we turn it into a LangChain 
+    <a href="https://python.langchain.com/docs/concepts/runnables/">Runnable</a>, 
+    which automatically enables calling <code>.invoke()</code>, <code>.stream()</code> and <code>.batch()</code> 
+    with your inputs
+  </li>
+  <li>
+    We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, 
+    human-in-the-loop workflows, time travel and more. In our case we use <code>MemorySaver</code> - 
+    a simple in-memory checkpointer
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Execute the graph.</summary>
+
+<ol>
+  <li>LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, <code>"agent"</code>.</li>
+  <li>The <code>"agent"</code> node executes, invoking the chat model.</li>
+  <li>The chat model returns an <code>AIMessage</code>. LangGraph adds this to the state.</li>
+  <li>Graph cycles the following steps until there are no more <code>tool_calls</code> on <code>AIMessage</code>:
+    <ul>
+      <li>If <code>AIMessage</code> has <code>tool_calls</code>, <code>"tools"</code> node executes</li>
+      <li>The <code>"agent"</code> node executes again and returns <code>AIMessage</code></li>
+    </ul>
+  </li>
+  <li>Execution progresses to the special <code>END</code> value and outputs the final state. And as a result, we get a list of all our chat messages as output.</li>
+</ol>
+</details>
+
+</details>
+
+## Documentation
+
+* [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
+* [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
+* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+
+## Resources
+
+* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
+
+## Contributing
+
+For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

docs/Makefile

@@ -10,15 +10,7 @@ build-prebuilt:
 	# Use to create an update to date prebuilt page.
 	# Looks up download stats for each of the prebuilt packages and
 	# generates the final prebuilt page.
-	@if [ "$(DOWNLOAD_STATS)" = "true" ]; then \
-		set -x; \
-		poetry run python -m _scripts.third_party_page.get_download_stats stats.yml; \
-		set +x; \
-	else \
-		set -x; \
-		poetry run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
-		set +x; \
-	fi
+	poetry run python -m _scripts.third_party_page.get_download_stats stats.yml
 	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/prebuilt.md --language python
 
 build-docs: build-typedoc build-prebuilt

docs/_scripts/notebook_hooks.py

@@ -186,7 +186,7 @@ def _on_page_markdown_with_config(
 
     if remove_base64_images:
         # Remove base64 encoded images from markdown
-        markdown = re.sub(r"!\[.*?\]\(data:image/[^;]+;base64,[^)]+\)", "", markdown)
+        markdown = re.sub(r"!\[.*?\]\(data:image/+;base64,[^\)]+\)", "", markdown)
 
     return markdown
 

docs/_scripts/third_party_page/get_download_stats.py

@@ -30,23 +30,10 @@ PACKAGES_FILE = HERE / "packages.yml"
 PACKAGES = yaml.safe_load(PACKAGES_FILE.read_text())['packages']
 
 
-def _get_weekly_downloads(packages: list[Package], fake: bool) -> list[ResolvedPackage]:
+def _get_weekly_downloads(packages: list[Package]) -> list[ResolvedPackage]:
     """Retrieve the monthly download count for a list of packages from PyPIStats."""
     resolved_packages: list[ResolvedPackage] = []
 
-    if fake:
-        # To avoid making network requests during testing, return fake download counts
-        for package in packages:
-            resolved_packages.append(
-                {
-                    "name": package["name"],
-                    "repo": package["repo"],
-                    "weekly_downloads": -12345,
-                    "description": package["description"],
-                }
-            )
-        return resolved_packages
-
     for package in packages:
         # First check if package exists on PyPI
         pypi_url = f"https://pypi.org/pypi/{package['name']}/json"
@@ -101,13 +88,13 @@ def _get_weekly_downloads(packages: list[Package], fake: bool) -> list[ResolvedP
 
 
 
-def main(output_file: str, fake: bool) -> None:
+def main(output_file: str) -> None:
     """Main function to generate package download information.
 
     Args:
         output_file: Path to the output YAML file.
     """
-    resolved_packages: list[ResolvedPackage] = _get_weekly_downloads(PACKAGES, fake)
+    resolved_packages: list[ResolvedPackage] = _get_weekly_downloads(PACKAGES)
 
     if not output_file.endswith(".yml"):
         raise ValueError("Output file must have a .yml extension")
@@ -128,15 +115,6 @@ if __name__ == "__main__":
             "downloads.yml"
         ),
     )
-    parser.add_argument(
-        "--fake",
-        default=False,
-        action="store_true",
-        help=(
-            "Generate fake download counts for testing purposes. "
-            "This option will not make any network requests."
-        ),
-    )
     args = parser.parse_args()
 
-    main(args.output_file, args.fake)
+    main(args.output_file)

docs/_scripts/third_party_page/packages.yml

@@ -30,6 +30,3 @@ packages:
   - name: "langgraph-bigtool"
     repo: "langchain-ai/langgraph-bigtool"
     description: "Build LangGraph agents with large numbers of tools."
-  - name: "langgraph-reflection"
-    repo: "langchain-ai/langgraph-reflection"
-    description: "LangGraph agent that runs a reflection step."

docs/docs/cloud/how-tos/generative_ui_react.md

@@ -1,312 +0,0 @@
-# How to implement Generative User Interfaces with LangGraph
-
-!!! info "Prerequisites"
-
-    - [LangGraph Platform](../../concepts/langgraph_platform.md)
-    - [LangGraph Server](../../concepts/langgraph_server.md)
-    - [`useStream()` React Hook](./use_stream_react.md)
-
-Generative user interfaces (Generative UI) allows agents to go beyond text and generate rich user interfaces. This enables creating more interactive and context-aware applications where the UI adapts based on the conversation flow and AI responses.
-
-![Generative UI Sample](./img/generative_ui_sample.jpg)
-
-LangGraph Platform supports colocating your React components with your graph code. This allows you to focus on building specific UI components for your graph while easily plugging into existing chat interfaces such as [Agent Chat](https://agentchat.vercel.app) and loading the code only when actually needed.
-
-!!! warning "LangGraph.js only"
-
-    Currently only LangGraph.js supports Generative UI. Support for Python is coming soon.
-
-## Tutorial
-
-### 1. Define and configure UI components
-
-First, create your first UI component. For each component you need to provide an unique identifier that will be used to reference the component in your graph code.
-
-```tsx title="src/agent/ui.tsx"
-const WeatherComponent = (props: { city: string }) => {
-  return <div>Weather for {props.city}</div>;
-};
-
-export default {
-  weather: WeatherComponent,
-};
-```
-
-Next, define your UI components in your `langgraph.json` configuration:
-
-```json
-{
-  "node_version": "20",
-  "graphs": {
-    "agent": "./src/agent/index.ts:graph"
-  },
-  "ui": {
-    "agent": "./src/agent/ui.tsx"
-  }
-}
-```
-
-The `ui` section points to the UI components that will be used by graphs. By default, we recommend using the same key as the graph name, but you can split out the components however you like, see [Customise the namespace of UI components](#customise-the-namespace-of-ui-components) for more details.
-
-LangGraph Platform will automatically bundle your UI components code and styles and serve them as external assets that can be loaded by the `LoadExternalComponent` component. Some dependencies such as `react` and `react-dom` will be automatically excluded from the bundle.
-
-CSS and Tailwind 4.x is also supported out of the box, so you can freely use Tailwind classes as well as `shadcn/ui` in your UI components.
-
-=== "`src/agent/ui.tsx`"
-
-    ```tsx
-    import "./styles.css";
-
-    const WeatherComponent = (props: { city: string }) => {
-      return <div className="bg-red-500">Weather for {props.city}</div>;
-    };
-
-    export default {
-      weather: WeatherComponent,
-    };
-    ```
-
-=== "`src/agent/styles.css`"
-
-    ```css
-    @import "tailwindcss";
-    ```
-
-### 2. Send the UI components in your graph
-
-Use the `typedUi` utility to emit UI elements from your agent nodes:
-
-```typescript title="src/agent/index.ts"
-import {
-  typedUi,
-  uiMessageReducer,
-} from "@langchain/langgraph-sdk/react-ui/server";
-
-import { ChatOpenAI } from "@langchain/openai";
-import { v4 as uuidv4 } from "uuid";
-import { z } from "zod";
-
-import type ComponentMap from "./ui.js";
-
-import {
-  Annotation,
-  MessagesAnnotation,
-  StateGraph,
-  type LangGraphRunnableConfig,
-} from "@langchain/langgraph";
-
-const AgentState = Annotation.Root({
-  ...MessagesAnnotation.spec,
-  ui: Annotation({ reducer: uiMessageReducer, default: () => [] }),
-});
-
-export const graph = new StateGraph(AgentState)
-  .addNode("weather", async (state, config) => {
-    // Provide the type of the component map to ensure
-    // type safety of `ui.push()` calls as well as
-    // pushing the messages to the `ui` and sending a custom event as well.
-    const ui = typedUi<typeof ComponentMap>(config);
-
-    const weather = await new ChatOpenAI({ model: "gpt-4o-mini" })
-      .withStructuredOutput(z.object({ city: z.string() }))
-      .withConfig({ tags: ["langsmith:nostream"] })
-      .invoke(state.messages);
-
-    const response = {
-      id: uuidv4(),
-      type: "ai",
-      content: `Here's the weather for ${weather.city}`,
-    };
-
-    // Emit UI elements with associated AI message
-    ui.push({ name: "weather", props: weather }, { message: response });
-
-    return { messages: [response] };
-  })
-  .addEdge("__start__", "weather")
-  .compile();
-```
-
-### 3. Handle UI elements in your React application
-
-On the client side, you can use `useStream()` and `LoadExternalComponent` to display the UI elements.
-
-```tsx title="src/app/page.tsx"
-"use client";
-
-import { useStream } from "@langchain/langgraph-sdk/react";
-import { LoadExternalComponent } from "@langchain/langgraph-sdk/react-ui";
-
-export default function Page() {
-  const { thread, values } = useStream({
-    apiUrl: "http://localhost:2024",
-    assistantId: "agent",
-  });
-
-  return (
-    <div>
-      {thread.messages.map((message) => (
-        <div key={message.id}>
-          {message.content}
-          {values.ui
-            ?.filter((ui) => ui.metadata?.message_id === message.id)
-            .map((ui) => (
-              <LoadExternalComponent key={ui.id} stream={thread} message={ui} />
-            ))}
-        </div>
-      ))}
-    </div>
-  );
-}
-```
-
-Behind the scenes, `LoadExternalComponent` will fetch the JS and CSS for the UI components from LangGraph Platform and render them in a shadow DOM, thus ensuring style isolation from the rest of your application.
-
-## How-to guides
-
-### Show loading UI when components are loading
-
-You can provide a fallback UI to be rendered when the components are loading.
-
-```tsx
-<LoadExternalComponent
-  stream={thread}
-  message={ui}
-  fallback={<div>Loading...</div>}
-/>
-```
-
-### Provide custom components on the client side
-
-If you already have the components loaded in your client application, you can provide a map of such components to be rendered directly without fetching the UI code from LangGraph Platform.
-
-```tsx
-const clientComponents = {
-  weather: WeatherComponent,
-};
-
-<LoadExternalComponent
-  stream={thread}
-  message={ui}
-  components={clientComponents}
-/>;
-```
-
-### Customise the namespace of UI components.
-
-By default `LoadExternalComponent` will use the `assistantId` from `useStream()` hook to fetch the code for UI components. You can customise this by providing a `namespace` prop to the `LoadExternalComponent` component.
-
-=== "`src/app/page.tsx`"
-
-    ```tsx
-    <LoadExternalComponent
-      stream={thread}
-      message={ui}
-      namespace="custom-namespace"
-    />
-    ```
-
-=== "`langgraph.json`"
-
-    ```json
-    {
-      "ui": {
-        "custom-namespace": "./src/agent/ui.tsx"
-      }
-    }
-    ```
-
-### Access and interact with the thread state from the UI component
-
-You can access the thread state inside the UI component by using the `useStreamContext` hook.
-
-```tsx
-import { useStreamContext } from "@langchain/langgraph-sdk/react-ui";
-
-const WeatherComponent = (props: { city: string }) => {
-  const { thread, submit } = useStreamContext();
-  return (
-    <>
-      <div>Weather for {props.city}</div>
-
-      <button
-        onClick={() => {
-          const newMessage = {
-            type: "human",
-            content: `What's the weather in ${props.city}?`,
-          };
-
-          submit({ messages: [newMessage] });
-        }}
-      >
-        Retry
-      </button>
-    </>
-  );
-};
-```
-
-### Pass additional context to the client components
-
-You can pass additional context to the client components by providing a `meta` prop to the `LoadExternalComponent` component.
-
-```tsx
-<LoadExternalComponent stream={thread} message={ui} meta={{ userId: "123" }} />
-```
-
-Then, you can access the `meta` prop in the UI component by using the `useStreamContext` hook.
-
-```tsx
-import { useStreamContext } from "@langchain/langgraph-sdk/react-ui";
-
-const WeatherComponent = (props: { city: string }) => {
-  const { meta } = useStreamContext<
-    { city: string },
-    { MetaType: { userId?: string } }
-  >();
-
-  return (
-    <div>
-      Weather for {props.city} (user: {meta?.userId})
-    </div>
-  );
-};
-```
-
-### Streaming UI updates before the node execution is finished
-
-You can stream UI updates before the node execution is finished by using the `onCustomEvent` callback of the `useStream()` hook.
-
-```tsx
-import { uiMessageReducer } from "@langchain/langgraph-sdk/react-ui";
-
-const { thread, submit } = useStream({
-  apiUrl: "http://localhost:2024",
-  assistantId: "agent",
-  onCustomEvent: (event, options) => {
-    options.mutate((prev) => {
-      const ui = uiMessageReducer(prev.ui ?? [], event);
-      return { ...prev, ui };
-    });
-  },
-});
-```
-
-### Remove UI messages from state
-
-Similar to how messages can be removed from the state by appending a RemoveMessage you can remove an UI message from the state by calling `ui.delete` with the ID of the UI message.
-
-```tsx
-// pushed message
-const message = ui.push({ name: "weather", props: { city: "London" } });
-
-// remove said message
-ui.delete(message.id);
-
-// return new state to persist changes
-return { ui: ui.items };
-```
-
-## Learn more
-
-- [JS/TS SDK Reference](../reference/sdk/js_ts_sdk_ref.md)

docs/docs/concepts/persistence.md

@@ -32,7 +32,7 @@ from typing_extensions import TypedDict
 from operator import add
 
 class State(TypedDict):
-    foo: str
+    foo: int
     bar: Annotated[list[str], add]
 
 def node_a(state: State):
@@ -232,7 +232,7 @@ from langgraph.store.memory import InMemoryStore
 in_memory_store = InMemoryStore()
 ```
 
-Memories are namespaced by a `tuple`, which in this specific example will be `(<user_id>, "memories")`. The namespace can be any length and represent anything, does not have to be user specific.
+Memories are namespaced by a `tuple`, which in this specific example will be `(<user_id>, "memories")`. The namespace can be any length and represent anything, does not have be user specific.
 
 ```python 
 user_id = "1"
@@ -387,9 +387,6 @@ We can access the memories and use them in our model call.
 def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
     # Get the user id from the config
     user_id = config["configurable"]["user_id"]
-
-    # Namespace the memory
-    namespace = (user_id, "memories")
     
     # Search based on the most recent message
     memories = store.search(

docs/docs/how-tos/create-react-agent-memory.ipynb

@@ -122,18 +122,20 @@
     "\n",
     "# For this tutorial we will use custom tool that returns pre-defined values for weather in two cities (NYC & SF)\n",
     "\n",
+    "from typing import Literal\n",
+    "\n",
     "from langchain_core.tools import tool\n",
     "\n",
     "\n",
     "@tool\n",
-    "def get_weather(location: str) -> str:\n",
+    "def get_weather(city: Literal[\"nyc\", \"sf\"]):\n",
     "    \"\"\"Use this to get weather information.\"\"\"\n",
-    "    if any([city in location.lower() for city in [\"nyc\", \"new york city\"]]):\n",
+    "    if city == \"nyc\":\n",
     "        return \"It might be cloudy in nyc\"\n",
-    "    elif any([city in location.lower() for city in [\"sf\", \"san francisco\"]]):\n",
+    "    elif city == \"sf\":\n",
     "        return \"It's always sunny in sf\"\n",
     "    else:\n",
-    "        return f\"I am not sure what the weather is in {location}\"\n",
+    "        raise AssertionError(\"Unknown city\")\n",
     "\n",
     "\n",
     "tools = [get_weather]\n",
@@ -218,7 +220,7 @@
    "id": "838a043f-90ad-4e69-9d1d-6e22db2c346c",
    "metadata": {},
    "source": [
-    "Notice that when we pass the same thread ID, the chat history is preserved."
+    "Notice that when we pass the same the same thread ID, the chat history is preserved"
    ]
   },
   {

docs/docs/how-tos/index.md

@@ -198,6 +198,7 @@ Learn how to set up your app for deployment to LangGraph Platform:
 - [How to test locally](../cloud/deployment/test_locally.md)
 - [How to rebuild graph at runtime](../cloud/deployment/graph_rebuild.md)
 - [How to use LangGraph Platform to deploy CrewAI, AutoGen, and other frameworks](autogen-langgraph-platform.ipynb)
+- [How to integrate LangGraph into your React application](../cloud/how-tos/use_stream_react.md)
 
 ### Deployment
 
@@ -256,13 +257,6 @@ Streaming the results of your LLM application is vital for ensuring a good user
 - [How to stream in debug mode](../cloud/how-tos/stream_debug.md)
 - [How to stream multiple modes](../cloud/how-tos/stream_multiple.md)
 
-### Frontend and Generative UI
-
-With LangGraph Platform you can integrate LangGraph agents into your React applications and colocate UI components with your agent code. 
-
-- [How to integrate LangGraph into your React application](../cloud/how-tos/use_stream_react.md)
-- [How to implement Generative User Interfaces with LangGraph](../cloud/how-tos/generative_ui_react.md)
-
 ### Human-in-the-loop
 
 When designing complex graphs, relying entirely on the LLM for decision-making can be risky, particularly when it involves tools that interact with files, APIs, or databases. These interactions may lead to unintended data access or modifications, depending on the use case. To mitigate these risks, LangGraph allows you to integrate human-in-the-loop behavior, ensuring your LLM applications operate as intended without undesirable outcomes.

docs/docs/how-tos/memory/add-summary-conversation-history.ipynb

@@ -10,7 +10,6 @@
     "One of the most common use cases for persistence is to use it to keep track of conversation history. This is great - it makes it easy to continue conversations. As conversations get longer and longer, however, this conversation history can build up and take up more and more of the context window. This can often be undesirable as it leads to more expensive and longer calls to the LLM, and potentially ones that error. One way to work around that is to create a summary of the conversation to date, and use that with the past N messages. This guide will go through an example of how to do that.\n",
     "\n",
     "This will involve a few steps:\n",
-    "\n",
     "- Check if the conversation is too long (can be done by checking number of messages or length of messages)\n",
     "- If yes, the create summary (will need a prompt for this)\n",
     "- Then remove all except the last N messages\n",

docs/docs/index.md

@@ -3,26 +3,4 @@ hide_comments: true
 title: Home
 ---
 
-<script>
-  // This script only runs in MkDocs, not on GitHub
-  var hideGitHubVersion = function() {
-    document.querySelectorAll('.github-only').forEach(el => el.style.display = 'none');
-  };
-
-  // Handle both initial load and subsequent navigation
-  document.addEventListener('DOMContentLoaded', hideGitHubVersion);
-  document$.subscribe(hideGitHubVersion);
-</script>
-
-<p class="mkdocs-only">
-  <img class="logo-light" src="static/wordmark_dark.svg" alt="LangGraph Logo" width="80%">
-  <img class="logo-dark" src="static/wordmark_light.svg" alt="LangGraph Logo" width="80%">
-</p>
-
-<style>
-h1 {
-  display: none;
-}
-</style>
-
 {!../README.md!}

docs/docs/llms.txt

@@ -1,191 +0,0 @@
-# LangGraph
-
-## Quickstart
-
-These guides are designed to help you get started with LangGraph.
-
-- [LangGraph Quickstart](https://langchain-ai.github.io/langgraph/tutorials/introduction/): Build a chatbot that can use tools and keep track of conversation history. Add human-in-the-loop capabilities and explore how time-travel works.
-- [Common Workflows](https://langchain-ai.github.io/langgraph/tutorials/workflows/): Overview of the most common workflows using LLMs implemented with LangGraph.
-- [LangGraph Server Quickstart](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/): Launch a LangGraph server locally and interact with it using REST API and LangGraph Studio Web UI.
-- [Deploy with LangGraph Cloud Quickstart](https://langchain-ai.github.io/langgraph/cloud/quick_start/): Deploy a LangGraph app using LangGraph Cloud.
-
-## Concepts
-
-These guides provide explanations of the key concepts behind the LangGraph framework.
-
-- [Why LangGraph?](https://langchain-ai.github.io/langgraph/concepts/high_level/): Motivation for LangGraph, a library for building agentic applications with LLMs.
-- [LangGraph Glossary](https://langchain-ai.github.io/langgraph/concepts/low_level/): LangGraph workflows are designed as graphs, with nodes representing different components and edges representing the flow of information between them. This guide provides an overview of the key concepts associated with LangGraph graph primitives.
-- [Common Agentic Patterns](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/): An agent uses an LLM to pick its own control flow to solve more complex problems! Agents are a key building block in many LLM applications. This guide explains the different types of agent architectures and how they can be used to control the flow of an application.
-- [Multi-Agent Systems](https://langchain-ai.github.io/langgraph/concepts/multi_agent/): Complex LLM applications can often be broken down into multiple agents, each responsible for a different part of the application. This guide explains common patterns for building multi-agent systems.
-- [Breakpoints](https://langchain-ai.github.io/langgraph/concepts/breakpoints/): Breakpoints allow pausing the execution of a graph at specific points. Breakpoints allow stepping through graph execution for debugging purposes.
-- [Human-in-the-Loop](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/): Explains different ways of integrating human feedback into a LangGraph application.
-- [Time Travel](https://langchain-ai.github.io/langgraph/concepts/time-travel/): Time travel allows you to replay past actions in your LangGraph application to explore alternative paths and debug issues.
-- [Persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/): LangGraph has a built-in persistence layer, implemented through checkpointers. This persistence layer helps to support powerful capabilities like human-in-the-loop, memory, time travel, and fault-tolerance.
-- [Memory](https://langchain-ai.github.io/langgraph/concepts/memory/): Memory in AI applications refers to the ability to process, store, and effectively recall information from past interactions. With memory, your agents can learn from feedback and adapt to users' preferences.
-- [Streaming](https://langchain-ai.github.io/langgraph/concepts/streaming/): Streaming is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs.
-- [Functional API](https://langchain-ai.github.io/langgraph/concepts/functional_api/): `@entrypoint` and `@task` decorators that allow you to add LangGraph functionality to an existing codebase.
-- [Durable Execution](https://langchain-ai.github.io/langgraph/concepts/durable_execution/): LangGraph's built-in [persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. 
-- [Pregel](https://langchain-ai.github.io/langgraph/concepts/pregel/): Pregel is LangGraph's runtime, which is responsible for managing the execution of LangGraph applications.
-- [FAQ](https://langchain-ai.github.io/langgraph/concepts/faq/): Frequently asked questions about LangGraph.
-
-## How-tos
-
-Here you’ll find answers to “How do I...?” types of questions. 
-
-These guides are **goal-oriented** and concrete. 
-
-They're meant to help you complete a specific task.
-
-### Graph API Basics
-
-- [How to update graph state from nodes](https://langchain-ai.github.io/langgraph/how-tos/state-reducers/)
-- [How to create a sequence of steps](https://langchain-ai.github.io/langgraph/how-tos/sequence/)
-- [How to create branches for parallel execution](https://langchain-ai.github.io/langgraph/how-tos/branching/)
-- [How to create and control loops with recursion limits](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/)
-- [How to visualize your graph](https://langchain-ai.github.io/langgraph/how-tos/visualization/)
-
-### Fine-grained Control
-
-These guides demonstrate LangGraph features that grant fine-grained control over the execution of your graph.
-
-- [How to create map-reduce branches for parallel execution](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/)
-- [How to update state and jump to nodes in graphs and subgraphs](https://langchain-ai.github.io/langgraph/how-tos/command/)
-- [How to add runtime configuration to your graph](https://langchain-ai.github.io/langgraph/how-tos/configuration/)
-- [How to add node retries](https://langchain-ai.github.io/langgraph/how-tos/node-retries/)
-- [How to return state before hitting recursion limit](https://langchain-ai.github.io/langgraph/how-tos/return-when-recursion-limit-hits/)
-
-### Persistence
- 
-Persistence makes it easy to persist state across graph runs (per-thread persistence) and across threads (cross-thread persistence). 
-
-These how-to guides show how to add persistence to your graph.
-
-- [How to add thread-level persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
-- [How to add thread-level persistence to a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-persistence/)
-- [How to add cross-thread persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence/)
-- [How to use Postgres checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_postgres/)
-- [How to use MongoDB checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_mongodb/)
-- [How to create a custom checkpointer using Redis](https://langchain-ai.github.io/langgraph/how-tos/persistence_redis/)
-
-See the below guides for how-to add persistence to your workflow using the [Functional API](https://langchain-ai.github.io/langgraph/concepts/functional_api/):
-
-- [How to add thread-level persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/persistence-functional/)
-- [How to add cross-thread persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence-functional/)
-
-### Memory
-
-LangGraph makes it easy to manage conversation memory in your graph. These how-to guides show how to implement different strategies for that.
-
-- [How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/)
-- [How to delete messages](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages/)
-- [How to add summary conversation memory](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/)
-- [How to add long-term memory (cross-thread)](https://langchain-ai.github.io/langgraph/how-tos/memory/cross-thread-persistence/)
-- [How to use semantic search for long-term memory](https://langchain-ai.github.io/langgraph/how-tos/memory/semantic-search/)
-
-### Human-in-the-loop
-
-Human-in-the-loop functionality allows you to involve humans in the decision-making process of your graph.
-
-These how-to guides show how to implement human-in-the-loop workflows in your graph.
-
-- [How to wait for user input](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/wait-user-input/): A basic example that shows how to implement a human-in-the-loop workflow in your graph using the `interrupt` function.
-- [How to review tool calls](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/review-tool-calls/): Incorporate human-in-the-loop for reviewing/editing/accepting tool call requests before they executed using the `interrupt` function.
-- [How to add static breakpoints](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/): Use for debugging purposes. For human-in-the-loop workflows, we recommend the [`interrupt` function](https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt) instead.
-- [How to edit graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/edit-graph-state/): Edit graph state using `graph.update_state` method. Use this if implementing a **human-in-the-loop** workflow via **static breakpoints**.
-
-See the below guides for how-to implement human-in-the-loop workflows with the Functional API.
-
-- [How to wait for user input (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/wait-user-input-functional/)
-- [How to review tool calls (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/review-tool-calls-functional/)
-
-### Time Travel
-
-[Time travel](https://langchain-ai.github.io/langgraph/concepts/time-travel/) allows you to replay past actions in your LangGraph application to explore alternative paths and debug issues. These how-to guides show how to use time travel in your graph.
-
-- [How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/time-travel/)
-
-### Streaming
-
-[Streaming](https://langchain-ai.github.io/langgraph/concepts/streaming/) is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs.
-
-- [How to stream](https://langchain-ai.github.io/langgraph/how-tos/streaming/)
-- [How to stream LLM tokens](https://langchain-ai.github.io/langgraph/how-tos/streaming-tokens/)
-- [How to stream LLM tokens from specific nodes](https://langchain-ai.github.io/langgraph/how-tos/streaming-specific-nodes/)
-- [How to stream data from within a tool](https://langchain-ai.github.io/langgraph/how-tos/streaming-events-from-within-tools/)
-- [How to stream from subgraphs](https://langchain-ai.github.io/langgraph/how-tos/streaming-subgraphs/)
-- [How to disable streaming for models that don't support it](https://langchain-ai.github.io/langgraph/how-tos/disable-streaming/)
-
-### Tool calling
-
-[Tool calling](https://python.langchain.com/docs/concepts/tool_calling/) is a type of [chat model](https://python.langchain.com/docs/concepts/chat_models/) API.
-
-It accepts tool schemas, along with messages, as input and returns invocations of those tools as part of the output message.
-
-These how-to guides show common patterns for tool calling with LangGraph:
-
-- [How to call tools using ToolNode](https://langchain-ai.github.io/langgraph/how-tos/tool-calling/)
-- [How to handle tool calling errors](https://langchain-ai.github.io/langgraph/how-tos/tool-calling-errors/)
-- [How to pass runtime values to tools](https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/)
-- [How to pass config to tools](https://langchain-ai.github.io/langgraph/how-tos/pass-config-to-tools/)
-- [How to update graph state from tools](https://langchain-ai.github.io/langgraph/how-tos/update-state-from-tools/)
-- [How to handle large numbers of tools](https://langchain-ai.github.io/langgraph/how-tos/many-tools/)
-
-### Subgraphs
-
-Subgraphs allow you to reuse an existing graph from another graph. 
-
-These how-to guides show how to use subgraphs:
-
-- [How to use subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraph/)
-- [How to view and update state in subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraphs-manage-state/)
-- [How to transform inputs and outputs of a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-transform-state/)
-
-### Multi-agent
-
-Multi-agent systems are useful to break down complex LLM applications into multiple agents, each responsible for a different part of the application. 
-
-These how-to guides show how to implement multi-agent systems in LangGraph:
-
-- [How to implement handoffs between agents](https://langchain-ai.github.io/langgraph/how-tos/agent-handoffs/)
-- [How to build a multi-agent network](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-network/)
-- [How to add multi-turn conversation in a multi-agent application](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-multi-turn-convo/)
-
-### State Management
-
-- [How to use Pydantic model as graph state](https://langchain-ai.github.io/langgraph/how-tos/state-model/)
-- [How to define input/output schema for your graph](https://langchain-ai.github.io/langgraph/how-tos/input_output_schema/)
-- [How to pass private state between nodes inside the graph](https://langchain-ai.github.io/langgraph/how-tos/pass_private_state/)
-
-### Other
-
-- [How to run graph asynchronously](https://langchain-ai.github.io/langgraph/how-tos/async/)
-- [How to force tool-calling agent to structure output](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/)
-- [How to pass custom LangSmith run ID for graph runs](https://langchain-ai.github.io/langgraph/how-tos/run-id-langsmith/)
-- [How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](https://langchain-ai.github.io/langgraph/how-tos/autogen-integration/)
-
-## Use cases 
-
-Explore practical implementations tailored for specific scenarios:
-
-### Chatbots
-
-- [Customer Support](https://langchain-ai.github.io/langgraph/tutorials/customer-support/customer-support/): Build a multi-functional support bot for flights, hotels, and car rentals.
-- [Prompt Generation from User Requirements](https://langchain-ai.github.io/langgraph/tutorials/chatbots/information-gather-prompting/): Build an information gathering chatbot.
-- [Code Assistant](https://langchain-ai.github.io/langgraph/tutorials/code_assistant/langgraph_code_assistant/): Build a code analysis and generation assistant.
-
-### RAG
-
-- [Agentic RAG](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_agentic_rag/): Use an agent to figure out how to retrieve the most relevant information before using the retrieved information to answer the user's question.
-- [Adaptive RAG](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag/): Adaptive RAG is a strategy for RAG that unites (1) query analysis with (2) active / self-corrective RAG. Implementation of: https://arxiv.org/abs/2403.14403
-    - For a version that uses a local LLM: [Adaptive RAG using local LLMs](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/)
-- [Corrective RAG](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_crag/): Uses an LLM to grade the quality of the retrieved information from the given source, and if the quality is low, it will try to retrieve the information from another source. Implementation of: https://arxiv.org/pdf/2401.15884.pdf 
-    - For a version that uses a local LLM: [Corrective RAG using local LLMs](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_crag_local/)
-- [Self-RAG](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_self_rag/): Self-RAG is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents and generations. Implementation of https://arxiv.org/abs/2310.11511.
-    - For a version that uses a local LLM: [Self-RAG using local LLMs](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_self_rag_local/) 
-- [SQL Agent](https://langchain-ai.github.io/langgraph/tutorials/sql-agent/): Build a SQL agent that can answer questions about a SQL database.
-
-### Multi-Agent Systems
-
-- [Network](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/multi-agent-collaboration/): Enable two or more agents to collaborate on a task
-- [Supervisor](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/): Use an LLM to orchestrate and delegate to individual agents
-- [Hierarchical Teams](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/): Orchestrate nested teams of agents to solve problems

docs/mkdocs.yml

@@ -85,7 +85,7 @@ plugins:
 
 nav:
   - Home:
-    - index.md
+    - Introduction: index.md
     - Get started:
       - Learn the basics: tutorials/introduction.ipynb
       - Deployment:
@@ -231,7 +231,6 @@ nav:
                 - cloud/how-tos/stream_debug.md
                 - cloud/how-tos/stream_multiple.md
                 - cloud/how-tos/use_stream_react.md
-                - cloud/how-tos/generative_ui_react.md
             - Human-in-the-loop:
                 - Human-in-the-loop: how-tos#human-in-the-loop_1
                 - cloud/how-tos/human_in_the_loop_breakpoint.md

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

@@ -2,7 +2,6 @@ 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
 
 import orjson
@@ -26,7 +25,6 @@ from langgraph.store.postgres.base import (
     PoolConfig,
     PostgresIndexConfig,
     Row,
-    TTLConfig,
     _decode_ns_bytes,
     _ensure_index_config,
     _group_ops,
@@ -108,11 +106,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         Semantic search is disabled by default. You can enable it by providing an `index` configuration
         when creating the store. Without this configuration, all `index` arguments passed to
         `put` or `aput` will have no effect.
-
-    Note:
-        If you provide a TTL configuration, you must explicitly call `start_ttl_sweeper()` to begin
-        the background task that removes expired items. Call `stop_ttl_sweeper()` to properly
-        clean up resources when you're done with the store.
     """
 
     __slots__ = (
@@ -122,11 +115,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         "supports_pipeline",
         "index_config",
         "embeddings",
-        "ttl_config",
-        "_ttl_sweeper_task",
-        "_ttl_stop_event",
     )
-    supports_ttl: bool = True
 
     def __init__(
         self,
@@ -137,7 +126,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
             Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
         ] = None,
         index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
     ) -> None:
         if isinstance(conn, AsyncConnectionPool) and pipe is not None:
             raise ValueError(
@@ -153,13 +141,10 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         self.index_config = index
         if self.index_config:
             self.embeddings, self.index_config = _ensure_index_config(self.index_config)
+
         else:
             self.embeddings = None
 
-        self.ttl_config = ttl
-        self._ttl_sweeper_task: Optional[asyncio.Task[None]] = None
-        self._ttl_stop_event = asyncio.Event()
-
     async def abatch(self, ops: Iterable[Op]) -> list[Result]:
         grouped_ops, num_ops = _group_ops(ops)
         results: list[Result] = [None] * num_ops
@@ -182,7 +167,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         pipeline: bool = False,
         pool_config: Optional[PoolConfig] = None,
         index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
     ) -> AsyncIterator["AsyncPostgresStore"]:
         """Create a new AsyncPostgresStore instance from a connection string.
 
@@ -214,16 +198,16 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
                     **cast(dict, pc),
                 ),
             ) as pool:
-                yield cls(conn=pool, index=index, ttl=ttl)
+                yield cls(conn=pool, index=index)
         else:
             async with await AsyncConnection.connect(
                 conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
             ) as conn:
                 if pipeline:
                     async with conn.pipeline() as pipe:
-                        yield cls(conn=conn, pipe=pipe, index=index, ttl=ttl)
+                        yield cls(conn=conn, pipe=pipe, index=index)
                 else:
-                    yield cls(conn=conn, index=index, ttl=ttl)
+                    yield cls(conn=conn, index=index)
 
     async def setup(self) -> None:
         """Set up the store database asynchronously.
@@ -272,119 +256,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
                         "INSERT INTO vector_migrations (v) VALUES (%s)", (v,)
                     )
 
-    async def sweep_ttl(self) -> int:
-        """Delete expired store items based on TTL.
-
-        Returns:
-            int: The number of deleted items.
-        """
-        async with self._cursor() as cur:
-            await cur.execute(
-                """
-                DELETE FROM store
-                WHERE expires_at IS NOT NULL AND expires_at < NOW()
-                """
-            )
-            deleted_count = cur.rowcount
-            return deleted_count
-
-    async def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
-    ) -> asyncio.Task[None]:
-        """Periodically delete expired store items based on TTL.
-
-        Returns:
-            Task that can be awaited or cancelled.
-        """
-        if not self.ttl_config:
-            return asyncio.create_task(asyncio.sleep(0))
-
-        if self._ttl_sweeper_task is not None and not self._ttl_sweeper_task.done():
-            return self._ttl_sweeper_task
-
-        self._ttl_stop_event.clear()
-
-        interval = float(
-            sweep_interval_minutes or self.ttl_config.get("sweep_interval_minutes") or 5
-        )
-        logger.info(f"Starting store TTL sweeper with interval {interval} minutes")
-
-        async def _sweep_loop() -> None:
-            while not self._ttl_stop_event.is_set():
-                try:
-                    try:
-                        await asyncio.wait_for(
-                            self._ttl_stop_event.wait(),
-                            timeout=interval * 60,
-                        )
-                        break
-                    except asyncio.TimeoutError:
-                        pass
-
-                    expired_items = await self.sweep_ttl()
-                    if expired_items > 0:
-                        logger.info(f"Store swept {expired_items} expired items")
-                except asyncio.CancelledError:
-                    break
-                except Exception as exc:
-                    logger.exception("Store TTL sweep iteration failed", exc_info=exc)
-
-        task = asyncio.create_task(_sweep_loop())
-        task.set_name("ttl_sweeper")
-        self._ttl_sweeper_task = task
-        return task
-
-    async def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
-        """Stop the TTL sweeper task if it's running.
-
-        Args:
-            timeout: Maximum time to wait for the task to stop, in seconds.
-                If None, wait indefinitely.
-
-        Returns:
-            bool: True if the task was successfully stopped or wasn't running,
-                False if the timeout was reached before the task stopped.
-        """
-        if self._ttl_sweeper_task is None or self._ttl_sweeper_task.done():
-            return True
-
-        logger.info("Stopping TTL sweeper task")
-        self._ttl_stop_event.set()
-
-        if timeout is not None:
-            try:
-                await asyncio.wait_for(self._ttl_sweeper_task, timeout=timeout)
-                success = True
-            except asyncio.TimeoutError:
-                success = False
-        else:
-            await self._ttl_sweeper_task
-            success = True
-
-        if success:
-            self._ttl_sweeper_task = None
-            logger.info("TTL sweeper task stopped")
-        else:
-            logger.warning("Timed out waiting for TTL sweeper task to stop")
-
-        return success
-
-    async def __aenter__(self) -> "AsyncPostgresStore":
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional["TracebackType"],
-    ) -> 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:
-            # Set the event to signal the task to stop
-            self._ttl_stop_event.set()
-            # We don't wait for the task to complete here to avoid blocking
-            # The task will clean up itself gracefully
-
     async def _execute_batch(
         self,
         grouped_ops: dict,

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

@@ -1,5 +1,4 @@
 import asyncio
-import concurrent.futures
 import json
 import logging
 import threading
@@ -40,7 +39,6 @@ from langgraph.store.base import (
     Result,
     SearchItem,
     SearchOp,
-    TTLConfig,
     ensure_embeddings,
     get_text_at_path,
     tokenize_path,
@@ -75,17 +73,6 @@ CREATE TABLE IF NOT EXISTS store (
     """
 -- For faster lookups by prefix
 CREATE INDEX CONCURRENTLY IF NOT EXISTS store_prefix_idx ON store USING btree (prefix text_pattern_ops);
-""",
-    """
--- Add expires_at column to store table
-ALTER TABLE store
-ADD COLUMN IF NOT EXISTS expires_at TIMESTAMP WITH TIME ZONE,
-ADD COLUMN IF NOT EXISTS ttl_minutes INT;
-""",
-    """
--- Add indexes for efficient TTL sweeping
-CREATE INDEX IF NOT EXISTS idx_store_expires_at ON store (expires_at)
-WHERE expires_at IS NOT NULL;
 """,
 ]
 
@@ -237,55 +224,20 @@ class BasePostgresStore(Generic[C]):
         self,
         get_ops: Sequence[tuple[int, GetOp]],
     ) -> list[tuple[str, tuple, tuple[str, ...], list]]:
-        """
-        Build queries to fetch (and optionally refresh the TTL of) multiple keys per namespace.
-
-        Each returned element is a tuple of:
-        (sql_query_string, sql_params, namespace, items_for_this_namespace)
-
-        where items_for_this_namespace is the original list of (idx, key, refresh_ttl).
-        """
-
         namespace_groups = defaultdict(list)
-        refresh_ttls = defaultdict(list)
         for idx, op in get_ops:
             namespace_groups[op.namespace].append((idx, op.key))
-            refresh_ttls[op.namespace].append(op.refresh_ttl)
-
         results = []
         for namespace, items in namespace_groups.items():
             _, keys = zip(*items)
-            this_refresh_ttls = refresh_ttls[namespace]
-
-            query = """
-                WITH passed_in AS (
-                    SELECT unnest(%s::text[]) AS key,
-                        unnest(%s::bool[])  AS do_refresh
-                ),
-                updated AS (
-                    UPDATE store s
-                    SET expires_at = NOW() + (s.ttl_minutes || ' minutes')::interval
-                    FROM passed_in p
-                    WHERE s.prefix = %s
-                    AND s.key    = p.key
-                    AND p.do_refresh = TRUE
-                    AND s.ttl_minutes IS NOT NULL
-                    RETURNING s.key
-                )
-                SELECT s.key, s.value, s.created_at, s.updated_at
-                FROM store s
-                JOIN passed_in p ON s.key = p.key
-                WHERE s.prefix = %s
+            keys_to_query = ",".join(["%s"] * len(keys))
+            query = f"""
+                SELECT key, value, created_at, updated_at
+                FROM store
+                WHERE prefix = %s AND key IN ({keys_to_query})
             """
-            ns_text = _namespace_to_text(namespace)
-            params = (
-                list(keys),  # -> unnest(%s::text[])
-                list(this_refresh_ttls),  # -> unnest(%s::bool[])
-                ns_text,  # -> prefix = %s (for UPDATE)
-                ns_text,  # -> prefix = %s (for final SELECT)
-            )
+            params = (_namespace_to_text(namespace), *keys)
             results.append((query, params, namespace, items))
-
         return results
 
     def _prepare_batch_PUT_queries(
@@ -295,6 +247,7 @@ class BasePostgresStore(Generic[C]):
         list[tuple[str, Sequence]],
         Optional[tuple[str, Sequence[tuple[str, str, str, str]]]],
     ]:
+        # Last-write wins
         dedupped_ops: dict[tuple[tuple[str, ...], str], PutOp] = {}
         for _, op in put_ops:
             dedupped_ops[(op.namespace, op.key)] = op
@@ -328,26 +281,15 @@ class BasePostgresStore(Generic[C]):
             insertion_params = []
             vector_values = []
             embedding_request_params = []
-            # Handle TTL expiration
 
             # First handle main store insertions
             for op in inserts:
-                if op.ttl is not None:
-                    expires_at_str = f"NOW() + INTERVAL '{op.ttl*60} seconds'"
-                    ttl_minutes = op.ttl
-                else:
-                    expires_at_str = "NULL"
-                    ttl_minutes = None
-
-                values.append(
-                    f"(%s, %s, %s, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, {expires_at_str}, %s)"
-                )
+                values.append("(%s, %s, %s, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)")
                 insertion_params.extend(
                     [
                         _namespace_to_text(op.namespace),
                         op.key,
                         Jsonb(cast(dict, op.value)),
-                        ttl_minutes,
                     ]
                 )
 
@@ -361,7 +303,7 @@ class BasePostgresStore(Generic[C]):
                     k = op.key
 
                     if op.index is None:
-                        paths = cast(dict, self.index_config)["__tokenized_fields"]
+                        paths = self.index_config["__tokenized_fields"]
                     else:
                         paths = [(ix, tokenize_path(ix)) for ix in op.index]
 
@@ -376,13 +318,11 @@ class BasePostgresStore(Generic[C]):
 
             values_str = ",".join(values)
             query = f"""
-                INSERT INTO store (prefix, key, value, created_at, updated_at, expires_at, ttl_minutes)
+                INSERT INTO store (prefix, key, value, created_at, updated_at)
                 VALUES {values_str}
                 ON CONFLICT (prefix, key) DO UPDATE
                 SET value = EXCLUDED.value,
-                    updated_at = CURRENT_TIMESTAMP,
-                    expires_at = EXCLUDED.expires_at,
-                    ttl_minutes = EXCLUDED.ttl_minutes
+                    updated_at = CURRENT_TIMESTAMP
             """
             queries.append((query, insertion_params))
 
@@ -406,105 +346,92 @@ class BasePostgresStore(Generic[C]):
         list[tuple[str, list[Union[None, str, list[float]]]]],  # queries, params
         list[tuple[int, str]],  # idx, query_text pairs to embed
     ]:
-        """
-        Build per-SearchOp SQL queries (with optional TTL refresh) plus embedding requests.
-        Returns:
-        - queries: list of (SQL, param_list)
-        - embedding_requests: list of (original_index_in_search_ops, text_query)
-        """
-
         queries = []
         embedding_requests = []
+
         for idx, (_, op) in enumerate(search_ops):
+            # Build filter conditions first
             filter_params = []
-            filter_clauses = []
+            filter_conditions = []
             if op.filter:
                 for key, value in op.filter.items():
                     if isinstance(value, dict):
                         for op_name, val in value.items():
-                            condition, params_ = self._get_filter_condition(
+                            condition, filter_params_ = self._get_filter_condition(
                                 key, op_name, val
                             )
-                            filter_clauses.append(condition)
-                            filter_params.extend(params_)
+                            filter_conditions.append(condition)
+                            filter_params.extend(filter_params_)
                     else:
-                        filter_clauses.append("value->%s = %s::jsonb")
-                        filter_params.extend([key, orjson.dumps(value).decode("utf-8")])
-
-            ns_condition = "TRUE"
-            ns_param: Optional[Sequence[Union[str]]] = None
-            if op.namespace_prefix:
-                ns_condition = "store.prefix LIKE %s"
-                ns_param = (f"{_namespace_to_text(op.namespace_prefix)}%",)
-            else:
-                ns_param = ()
-
-            extra_filters = (
-                " AND " + " AND ".join(filter_clauses) if filter_clauses else ""
-            )
+                        filter_conditions.append("value->%s = %s::jsonb")
+                        filter_params.extend([key, json.dumps(value)])
 
+            # Vector search branch
             if op.query and self.index_config:
-                # We'll embed the text later, so record the request.
                 embedding_requests.append((idx, op.query))
 
                 score_operator, post_operator = get_distance_operator(self)
-                post_operator = post_operator.replace("scored", "uniq")
                 vector_type = (
                     cast(PostgresIndexConfig, self.index_config)
                     .get("ann_index_config", {})
                     .get("vector_type", "vector")
                 )
 
-                # For hamming bit vectors, or “regular” vectors
                 if (
                     vector_type == "bit"
-                    and cast(dict, self.index_config).get("distance_type") == "hamming"
+                    and self.index_config.get("distance_type") == "hamming"
                 ):
                     score_operator = score_operator % (
                         "%s",
-                        cast(dict, self.index_config)["dims"],
+                        self.index_config["dims"],
                     )
                 else:
-                    score_operator = score_operator % ("%s", vector_type)
+                    score_operator = score_operator % (
+                        "%s",
+                        vector_type,
+                    )
 
-                vectors_per_doc_estimate = cast(dict, self.index_config)[
-                    "__estimated_num_vectors"
-                ]
+                vectors_per_doc_estimate = self.index_config["__estimated_num_vectors"]
                 expanded_limit = (op.limit * vectors_per_doc_estimate * 2) + 1
 
-                # “sub_scored” does the main vector search
-                # Then we do DISTINCT ON to drop duplicates if your store can have them
-                # Finally we limit & offset
-                vector_search_cte = f"""
-                        SELECT store.prefix, store.key, store.value, store.created_at, store.updated_at,
-                            {score_operator} AS neg_score
-                        FROM store
-                        JOIN store_vectors sv ON store.prefix = sv.prefix AND store.key = sv.key
-                        WHERE {ns_condition} {extra_filters}
-                        ORDER BY {score_operator} ASC
-                        LIMIT %s
-                    """
+                # Vector search with CTE for proper score handling
+                filter_str = (
+                    ""
+                    if not filter_conditions
+                    else " AND " + " AND ".join(filter_conditions)
+                )
+                if op.namespace_prefix:
+                    prefix_filter_str = f"WHERE s.prefix LIKE %s {filter_str} "
+                    ns_args: Sequence = (f"{_namespace_to_text(op.namespace_prefix)}%",)
+                else:
+                    ns_args = ()
+                    if filter_str:
+                        prefix_filter_str = f"WHERE {filter_str} "
+                    else:
+                        prefix_filter_str = ""
 
-                search_results_sql = f"""
-                        WITH scored AS (
-                            {vector_search_cte}
-                        )
-                        SELECT uniq.prefix, uniq.key, uniq.value, uniq.created_at, uniq.updated_at,
-                            {post_operator} AS score
-                        FROM (
-                            SELECT DISTINCT ON (scored.prefix, scored.key)
-                                scored.prefix, scored.key, scored.value, scored.created_at, scored.updated_at, scored.neg_score
-                            FROM scored
-                            ORDER BY scored.prefix, scored.key, scored.neg_score ASC
-                        ) uniq
-                        ORDER BY score DESC
+                base_query = f"""
+                    WITH scored AS (
+                        SELECT s.prefix, s.key, s.value, s.created_at, s.updated_at, {score_operator} AS neg_score
+                        FROM store s
+                        JOIN store_vectors sv ON s.prefix = sv.prefix AND s.key = sv.key
+                        {prefix_filter_str}
+                        ORDER BY {score_operator} ASC 
                         LIMIT %s
-                        OFFSET %s
-                    """
-
-                search_results_params = [
-                    PLACEHOLDER,
-                    *ns_param,
+                    )
+                    SELECT * FROM (
+                        SELECT DISTINCT ON (prefix, key) 
+                            prefix, key, value, created_at, updated_at, {post_operator} as score 
+                        FROM scored 
+                        ORDER BY prefix, key, score DESC
+                    ) AS unique_docs
+                    ORDER BY score DESC
+                    LIMIT %s
+                    OFFSET %s
+                """
+                params = [
+                    PLACEHOLDER,  # Vector placeholder
+                    *ns_args,
                     *filter_params,
                     PLACEHOLDER,
                     expanded_limit,
@@ -512,45 +439,24 @@ class BasePostgresStore(Generic[C]):
                     op.offset,
                 ]
 
+            # Regular search branch
             else:
-                base_query = f"""
-                        SELECT store.prefix, store.key, store.value, store.created_at, store.updated_at, NULL AS score
-                        FROM store
-                        WHERE {ns_condition} {extra_filters}
-                        ORDER BY store.updated_at DESC
-                        LIMIT %s
-                        OFFSET %s
-                    """
-                search_results_sql = base_query
-                search_results_params = [
-                    *ns_param,
-                    *filter_params,
-                    op.limit,
-                    op.offset,
-                ]
+                base_query = """
+                    SELECT prefix, key, value, created_at, updated_at
+                    FROM store
+                    WHERE prefix LIKE %s
+                """
+                params = [f"{_namespace_to_text(op.namespace_prefix)}%"]
 
-            if op.refresh_ttl:
-                # Wrap entire primary query in a CTE, then perform "update_at"
-                final_sql = f"""
-                        WITH search_results AS (
-                            {search_results_sql}
-                        ),
-                        updated AS (
-                            UPDATE store s
-                            SET expires_at = NOW() + (s.ttl_minutes || ' minutes')::interval
-                            FROM search_results sr
-                            WHERE s.prefix = sr.prefix
-                            AND s.key = sr.key
-                            AND s.ttl_minutes IS NOT NULL
-                        )
-                        SELECT sr.prefix, sr.key, sr.value, sr.created_at, sr.updated_at, sr.score
-                        FROM search_results sr
-                    """
-                final_params = search_results_params[:]  # copy
-            else:
-                final_sql = search_results_sql
-                final_params = search_results_params
-            queries.append((final_sql, final_params))
+                if filter_conditions:
+                    params.extend(filter_params)
+                    base_query += " AND " + " AND ".join(filter_conditions)
+
+                base_query += " ORDER BY updated_at DESC"
+                base_query += " LIMIT %s OFFSET %s"
+                params.extend([op.limit, op.offset])
+
+            queries.append((base_query, params))
 
         return queries, embedding_requests
 
@@ -696,11 +602,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         Make sure to call `setup()` before first use to create necessary tables and indexes.
         The pgvector extension must be available to use vector search.
 
-    Note:
-        If you provide a TTL configuration, you must explicitly call `start_ttl_sweeper()` to begin
-        the background thread that removes expired items. Call `stop_ttl_sweeper()` to properly
-        clean up resources when you're done with the store.
-
     """
 
     __slots__ = (
@@ -710,10 +611,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         "supports_pipeline",
         "index_config",
         "embeddings",
-        "_ttl_sweeper_thread",
-        "_ttl_stop_event",
     )
-    supports_ttl: bool = True
 
     def __init__(
         self,
@@ -724,7 +622,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
             Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
         ] = None,
         index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
     ) -> None:
         super().__init__()
         self._deserializer = deserializer
@@ -737,9 +634,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
             self.embeddings, self.index_config = _ensure_index_config(self.index_config)
         else:
             self.embeddings = None
-        self.ttl_config = ttl
-        self._ttl_sweeper_thread: Optional[threading.Thread] = None
-        self._ttl_stop_event = threading.Event()
 
     @classmethod
     @contextmanager
@@ -750,7 +644,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         pipeline: bool = False,
         pool_config: Optional[PoolConfig] = None,
         index: Optional[PostgresIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
     ) -> Iterator["PostgresStore"]:
         """Create a new PostgresStore instance from a connection string.
 
@@ -782,123 +675,16 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
                     **cast(dict, pc),
                 ),
             ) as pool:
-                yield cls(conn=pool, index=index, ttl=ttl)
+                yield cls(conn=pool, index=index)
         else:
             with Connection.connect(
                 conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
             ) as conn:
                 if pipeline:
                     with conn.pipeline() as pipe:
-                        yield cls(conn, pipe=pipe, index=index, ttl=ttl)
+                        yield cls(conn, pipe=pipe, index=index)
                 else:
-                    yield cls(conn, index=index, ttl=ttl)
-
-    def sweep_ttl(self) -> int:
-        """Delete expired store items based on TTL.
-
-        Returns:
-            int: The number of deleted items.
-        """
-        with self._cursor() as cur:
-            cur.execute(
-                """
-                DELETE FROM store
-                WHERE expires_at IS NOT NULL AND expires_at < NOW()
-                """
-            )
-            deleted_count = cur.rowcount
-            return deleted_count
-
-    def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
-    ) -> concurrent.futures.Future[None]:
-        """Periodically delete expired store items based on TTL.
-
-        Returns:
-            Future that can be waited on or cancelled.
-        """
-        if not self.ttl_config:
-            future: concurrent.futures.Future[None] = concurrent.futures.Future()
-            future.set_result(None)
-            return future
-
-        if self._ttl_sweeper_thread and self._ttl_sweeper_thread.is_alive():
-            logger.info("TTL sweeper thread is already running")
-            # Return a future that can be used to cancel the existing thread
-            future = concurrent.futures.Future()
-            future.add_done_callback(
-                lambda f: self._ttl_stop_event.set() if f.cancelled() else None
-            )
-            return future
-
-        self._ttl_stop_event.clear()
-
-        interval = float(
-            sweep_interval_minutes or self.ttl_config.get("sweep_interval_minutes") or 5
-        )
-        logger.info(f"Starting store TTL sweeper with interval {interval} minutes")
-
-        future = concurrent.futures.Future()
-
-        def _sweep_loop() -> None:
-            try:
-                while not self._ttl_stop_event.is_set():
-                    if self._ttl_stop_event.wait(interval * 60):
-                        break
-
-                    try:
-                        expired_items = self.sweep_ttl()
-                        if expired_items > 0:
-                            logger.info(f"Store swept {expired_items} expired items")
-                    except Exception as exc:
-                        logger.exception(
-                            "Store TTL sweep iteration failed", exc_info=exc
-                        )
-                future.set_result(None)
-            except Exception as exc:
-                future.set_exception(exc)
-
-        thread = threading.Thread(target=_sweep_loop, daemon=True, name="ttl-sweeper")
-        self._ttl_sweeper_thread = thread
-        thread.start()
-
-        future.add_done_callback(
-            lambda f: self._ttl_stop_event.set() if f.cancelled() else None
-        )
-        return future
-
-    def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
-        """Stop the TTL sweeper thread if it's running.
-
-        Args:
-            timeout: Maximum time to wait for the thread to stop, in seconds.
-                If None, wait indefinitely.
-
-        Returns:
-            bool: True if the thread was successfully stopped or wasn't running,
-                False if the timeout was reached before the thread stopped.
-        """
-        if not self._ttl_sweeper_thread or not self._ttl_sweeper_thread.is_alive():
-            return True
-
-        logger.info("Stopping TTL sweeper thread")
-        self._ttl_stop_event.set()
-
-        self._ttl_sweeper_thread.join(timeout)
-        success = not self._ttl_sweeper_thread.is_alive()
-
-        if success:
-            self._ttl_sweeper_thread = None
-            logger.info("TTL sweeper thread stopped")
-        else:
-            logger.warning("Timed out waiting for TTL sweeper thread to stop")
-
-        return success
-
-    def __del__(self) -> None:
-        """Ensure the TTL sweeper thread is stopped when the object is garbage collected."""
-        if hasattr(self, "_ttl_stop_event") and hasattr(self, "_ttl_sweeper_thread"):
-            self.stop_ttl_sweeper(timeout=0.1)
+                    yield cls(conn, index=index)
 
     @contextmanager
     def _cursor(self, *, pipeline: bool = False) -> Iterator[Cursor[DictRow]]:
@@ -1097,14 +883,8 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         with self._cursor() as cur:
             version = _get_version(cur, table="store_migrations")
             for v, sql in enumerate(self.MIGRATIONS[version + 1 :], start=version + 1):
-                try:
-                    cur.execute(sql)
-                    cur.execute("INSERT INTO store_migrations (v) VALUES (%s)", (v,))
-                except Exception as e:
-                    logger.error(
-                        f"Failed to apply migration {v}.\nSql={sql}\nError={e}"
-                    )
-                    raise
+                cur.execute(sql)
+                cur.execute("INSERT INTO store_migrations (v) VALUES (%s)", (v,))
 
             if self.index_config:
                 version = _get_version(cur, table="vector_migrations")

libs/checkpoint-postgres/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.18"
+version = "2.0.15"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 authors = []
 license = "MIT"

libs/checkpoint-postgres/tests/test_async_store.py

@@ -26,9 +26,6 @@ from tests.conftest import (
     CharacterEmbeddings,
 )
 
-TTL_SECONDS = 6
-TTL_MINUTES = TTL_SECONDS / 60
-
 
 @pytest.fixture(scope="function", params=["default", "pipe", "pool"])
 async def store(request) -> AsyncIterator[AsyncPostgresStore]:
@@ -45,54 +42,28 @@ async def store(request) -> AsyncIterator[AsyncPostgresStore]:
 
     conn_string = f"{uri_base}/{database}{query_params}"
     admin_conn_string = DEFAULT_URI
-    ttl_config = {
-        "default_ttl": TTL_MINUTES,
-        "refresh_on_read": True,
-        "sweep_interval_minutes": TTL_MINUTES / 2,
-    }
+
     async with await AsyncConnection.connect(
         admin_conn_string, autocommit=True
     ) as conn:
         await conn.execute(f"CREATE DATABASE {database}")
     try:
-        async with AsyncPostgresStore.from_conn_string(
-            conn_string, ttl=ttl_config
-        ) as store:
-            store.MIGRATIONS = [
-                (
-                    mig.replace("ttl_minutes INT;", "ttl_minutes FLOAT;")
-                    if isinstance(mig, str)
-                    else mig
-                )
-                for mig in store.MIGRATIONS
-            ]
+        async with AsyncPostgresStore.from_conn_string(conn_string) as store:
             await store.setup()
-            async with store._cursor() as cur:
-                # drop the migration index
-                await cur.execute("DROP TABLE IF EXISTS store_migrations")
-            await store.setup()  # Will fail if migrations aren't idempotent
 
         if request.param == "pipe":
             async with AsyncPostgresStore.from_conn_string(
-                conn_string, pipeline=True, ttl=ttl_config
+                conn_string, pipeline=True
             ) as store:
-                await store.start_ttl_sweeper()
                 yield store
-                await store.stop_ttl_sweeper()
         elif request.param == "pool":
             async with AsyncPostgresStore.from_conn_string(
-                conn_string, pool_config={"min_size": 1, "max_size": 10}, ttl=ttl_config
+                conn_string, pool_config={"min_size": 1, "max_size": 10}
             ) as store:
-                await store.start_ttl_sweeper()
                 yield store
-                await store.stop_ttl_sweeper()
         else:  # default
-            async with AsyncPostgresStore.from_conn_string(
-                conn_string, ttl=ttl_config
-            ) as store:
-                await store.start_ttl_sweeper()
+            async with AsyncPostgresStore.from_conn_string(conn_string) as store:
                 yield store
-                await store.stop_ttl_sweeper()
     finally:
         async with await AsyncConnection.connect(
             admin_conn_string, autocommit=True
@@ -664,28 +635,3 @@ async def test_search_sorting(
         assert len(set(r.key for r in results)) == 10
         assert results[0].key == "M"
         assert results[0].score > results[1].score
-
-
-async def test_store_ttl(store):
-    # Assumes a TTL of 1 minute = 60 seconds
-    ns = ("foo",)
-    await store.start_ttl_sweeper()
-    await store.aput(
-        ns,
-        key="item1",
-        value={"foo": "bar"},
-        ttl=TTL_MINUTES,  # type: ignore
-    )
-    await asyncio.sleep(TTL_SECONDS - 2)
-    res = await store.aget(ns, key="item1", refresh_ttl=True)
-    assert res is not None
-    await asyncio.sleep(TTL_SECONDS - 2)
-    results = await store.asearch(ns, query="foo", refresh_ttl=True)
-    assert len(results) == 1
-    await asyncio.sleep(TTL_SECONDS - 2)
-    res = await store.aget(ns, key="item1", refresh_ttl=False)
-    assert res is not None
-    await asyncio.sleep(TTL_SECONDS - 1)
-    # Now has been (TTL_SECONDS-2)*2 > TTL_SECONDS + TTL_SECONDS/2
-    results = await store.asearch(ns, query="bar", refresh_ttl=False)
-    assert len(results) == 0

libs/checkpoint-postgres/tests/test_store.py

@@ -1,7 +1,6 @@
 # type: ignore
 
 import re
-import time
 from contextlib import contextmanager
 from typing import Any, Optional
 from uuid import uuid4
@@ -25,9 +24,6 @@ from tests.conftest import (
     CharacterEmbeddings,
 )
 
-TTL_SECONDS = 6
-TTL_MINUTES = TTL_SECONDS / 60
-
 
 @pytest.fixture(scope="function", params=["default", "pipe", "pool"])
 def store(request) -> PostgresStore:
@@ -36,56 +32,29 @@ def store(request) -> PostgresStore:
     uri_base = "/".join(uri_parts[:-1])
     query_params = ""
     if "?" in uri_parts[-1]:
-        _, query_params = uri_parts[-1].split("?", 1)
+        db_name, query_params = uri_parts[-1].split("?", 1)
         query_params = "?" + query_params
 
     conn_string = f"{uri_base}/{database}{query_params}"
     admin_conn_string = DEFAULT_URI
-    ttl_config = {
-        "default_ttl": TTL_MINUTES,
-        "refresh_on_read": True,
-        "sweep_interval_minutes": TTL_MINUTES / 2,
-    }
+
     with Connection.connect(admin_conn_string, autocommit=True) as conn:
         conn.execute(f"CREATE DATABASE {database}")
     try:
-        with PostgresStore.from_conn_string(conn_string, ttl=ttl_config) as store:
-            store.MIGRATIONS = [
-                (
-                    mig.replace("ttl_minutes INT;", "ttl_minutes FLOAT;")
-                    if isinstance(mig, str)
-                    else mig
-                )
-                for mig in store.MIGRATIONS
-            ]
+        with PostgresStore.from_conn_string(conn_string) as store:
             store.setup()
 
         if request.param == "pipe":
-            with PostgresStore.from_conn_string(
-                conn_string,
-                pipeline=True,
-                ttl=ttl_config,
-            ) as store:
-                store.start_ttl_sweeper()
+            with PostgresStore.from_conn_string(conn_string, pipeline=True) as store:
                 yield store
-
-                store.stop_ttl_sweeper()
         elif request.param == "pool":
             with PostgresStore.from_conn_string(
-                conn_string,
-                pool_config={"min_size": 1, "max_size": 10},
-                ttl=ttl_config,
+                conn_string, pool_config={"min_size": 1, "max_size": 10}
             ) as store:
-                store.start_ttl_sweeper()
                 yield store
-
-                store.stop_ttl_sweeper()
         else:  # default
-            with PostgresStore.from_conn_string(conn_string, ttl=ttl_config) as store:
-                store.start_ttl_sweeper()
+            with PostgresStore.from_conn_string(conn_string) as store:
                 yield store
-
-                store.stop_ttl_sweeper()
     finally:
         with Connection.connect(admin_conn_string, autocommit=True) as conn:
             conn.execute(f"DROP DATABASE {database}")
@@ -251,127 +220,134 @@ def test_batch_list_namespaces_ops(store: PostgresStore) -> None:
     assert all(ns[-1] == "public" for ns in results[2])
 
 
-def test_basic_store_ops(store) -> None:
-    namespace = ("test", "documents")
-    item_id = "doc1"
-    item_value = {"title": "Test Document", "content": "Hello, World!"}
+class TestPostgresStore:
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        with PostgresStore.from_conn_string(DEFAULT_URI) as store:
+            store.setup()
 
-    store.put(namespace, item_id, item_value)
-    item = store.get(namespace, item_id)
+    def test_basic_store_ops(self) -> None:
+        with PostgresStore.from_conn_string(DEFAULT_URI) as store:
+            namespace = ("test", "documents")
+            item_id = "doc1"
+            item_value = {"title": "Test Document", "content": "Hello, World!"}
 
-    assert item
-    assert item.namespace == namespace
-    assert item.key == item_id
-    assert item.value == item_value
+            store.put(namespace, item_id, item_value)
+            item = store.get(namespace, item_id)
 
-    # Test update
-    updated_value = {"title": "Updated Document", "content": "Hello, Updated!"}
-    store.put(namespace, item_id, updated_value)
-    updated_item = store.get(namespace, item_id)
+            assert item
+            assert item.namespace == namespace
+            assert item.key == item_id
+            assert item.value == item_value
 
-    assert updated_item.value == updated_value
-    assert updated_item.updated_at > item.updated_at
+            # Test update
+            updated_value = {"title": "Updated Document", "content": "Hello, Updated!"}
+            store.put(namespace, item_id, updated_value)
+            updated_item = store.get(namespace, item_id)
 
-    # Test get from non-existent namespace
-    different_namespace = ("test", "other_documents")
-    item_in_different_namespace = store.get(different_namespace, item_id)
-    assert item_in_different_namespace is None
+            assert updated_item.value == updated_value
+            assert updated_item.updated_at > item.updated_at
 
-    # Test delete
-    store.delete(namespace, item_id)
-    deleted_item = store.get(namespace, item_id)
-    assert deleted_item is None
+            # Test get from non-existent namespace
+            different_namespace = ("test", "other_documents")
+            item_in_different_namespace = store.get(different_namespace, item_id)
+            assert item_in_different_namespace is None
 
+            # Test delete
+            store.delete(namespace, item_id)
+            deleted_item = store.get(namespace, item_id)
+            assert deleted_item is None
 
-def test_list_namespaces(store) -> None:
-    # Create test data with various namespaces
-    test_namespaces = [
-        ("test", "documents", "public"),
-        ("test", "documents", "private"),
-        ("test", "images", "public"),
-        ("test", "images", "private"),
-        ("prod", "documents", "public"),
-        ("prod", "documents", "private"),
-    ]
+    def test_list_namespaces(self) -> None:
+        with PostgresStore.from_conn_string(DEFAULT_URI) as store:
+            # Create test data with various namespaces
+            test_namespaces = [
+                ("test", "documents", "public"),
+                ("test", "documents", "private"),
+                ("test", "images", "public"),
+                ("test", "images", "private"),
+                ("prod", "documents", "public"),
+                ("prod", "documents", "private"),
+            ]
 
-    # Insert test data
-    for namespace in test_namespaces:
-        store.put(namespace, "dummy", {"content": "dummy"})
+            # Insert test data
+            for namespace in test_namespaces:
+                store.put(namespace, "dummy", {"content": "dummy"})
 
-    # Test listing with various filters
-    all_namespaces = store.list_namespaces()
-    assert len(all_namespaces) == len(test_namespaces)
+            # Test listing with various filters
+            all_namespaces = store.list_namespaces()
+            assert len(all_namespaces) == len(test_namespaces)
 
-    # Test prefix filtering
-    test_prefix_namespaces = store.list_namespaces(prefix=["test"])
-    assert len(test_prefix_namespaces) == 4
-    assert all(ns[0] == "test" for ns in test_prefix_namespaces)
+            # Test prefix filtering
+            test_prefix_namespaces = store.list_namespaces(prefix=["test"])
+            assert len(test_prefix_namespaces) == 4
+            assert all(ns[0] == "test" for ns in test_prefix_namespaces)
 
-    # Test suffix filtering
-    public_namespaces = store.list_namespaces(suffix=["public"])
-    assert len(public_namespaces) == 3
-    assert all(ns[-1] == "public" for ns in public_namespaces)
+            # Test suffix filtering
+            public_namespaces = store.list_namespaces(suffix=["public"])
+            assert len(public_namespaces) == 3
+            assert all(ns[-1] == "public" for ns in public_namespaces)
 
-    # Test max depth
-    depth_2_namespaces = store.list_namespaces(max_depth=2)
-    assert all(len(ns) <= 2 for ns in depth_2_namespaces)
+            # Test max depth
+            depth_2_namespaces = store.list_namespaces(max_depth=2)
+            assert all(len(ns) <= 2 for ns in depth_2_namespaces)
 
-    # Test pagination
-    paginated_namespaces = store.list_namespaces(limit=3)
-    assert len(paginated_namespaces) == 3
+            # Test pagination
+            paginated_namespaces = store.list_namespaces(limit=3)
+            assert len(paginated_namespaces) == 3
 
-    # Cleanup
-    for namespace in test_namespaces:
-        store.delete(namespace, "dummy")
+            # Cleanup
+            for namespace in test_namespaces:
+                store.delete(namespace, "dummy")
 
+    def test_search(self) -> None:
+        with PostgresStore.from_conn_string(DEFAULT_URI) as store:
+            # Create test data
+            test_data = [
+                (
+                    ("test", "docs"),
+                    "doc1",
+                    {"title": "First Doc", "author": "Alice", "tags": ["important"]},
+                ),
+                (
+                    ("test", "docs"),
+                    "doc2",
+                    {"title": "Second Doc", "author": "Bob", "tags": ["draft"]},
+                ),
+                (
+                    ("test", "images"),
+                    "img1",
+                    {"title": "Image 1", "author": "Alice", "tags": ["final"]},
+                ),
+            ]
 
-def test_search(store) -> None:
-    # Create test data
-    test_data = [
-        (
-            ("test", "docs"),
-            "doc1",
-            {"title": "First Doc", "author": "Alice", "tags": ["important"]},
-        ),
-        (
-            ("test", "docs"),
-            "doc2",
-            {"title": "Second Doc", "author": "Bob", "tags": ["draft"]},
-        ),
-        (
-            ("test", "images"),
-            "img1",
-            {"title": "Image 1", "author": "Alice", "tags": ["final"]},
-        ),
-    ]
+            for namespace, key, value in test_data:
+                store.put(namespace, key, value)
 
-    for namespace, key, value in test_data:
-        store.put(namespace, key, value)
+            # Test basic search
+            all_items = store.search(["test"])
+            assert len(all_items) == 3
 
-    # Test basic search
-    all_items = store.search(["test"])
-    assert len(all_items) == 3
+            # Test namespace filtering
+            docs_items = store.search(["test", "docs"])
+            assert len(docs_items) == 2
+            assert all(item.namespace == ("test", "docs") for item in docs_items)
 
-    # Test namespace filtering
-    docs_items = store.search(["test", "docs"])
-    assert len(docs_items) == 2
-    assert all(item.namespace == ("test", "docs") for item in docs_items)
+            # Test value filtering
+            alice_items = store.search(["test"], filter={"author": "Alice"})
+            assert len(alice_items) == 2
+            assert all(item.value["author"] == "Alice" for item in alice_items)
 
-    # Test value filtering
-    alice_items = store.search(["test"], filter={"author": "Alice"})
-    assert len(alice_items) == 2
-    assert all(item.value["author"] == "Alice" for item in alice_items)
+            # Test pagination
+            paginated_items = store.search(["test"], limit=2)
+            assert len(paginated_items) == 2
 
-    # Test pagination
-    paginated_items = store.search(["test"], limit=2)
-    assert len(paginated_items) == 2
+            offset_items = store.search(["test"], offset=2)
+            assert len(offset_items) == 1
 
-    offset_items = store.search(["test"], offset=2)
-    assert len(offset_items) == 1
-
-    # Cleanup
-    for namespace, key, _ in test_data:
-        store.delete(namespace, key)
+            # Cleanup
+            for namespace, key, _ in test_data:
+                store.delete(namespace, key)
 
 
 @contextmanager
@@ -380,7 +356,6 @@ def _create_vector_store(
     distance_type: str,
     fake_embeddings: Embeddings,
     text_fields: Optional[list[str]] = None,
-    enable_ttl: bool = True,
 ) -> PostgresStore:
     """Create a store with vector search enabled."""
     database = f"test_{uuid4().hex[:16]}"
@@ -410,32 +385,23 @@ def _create_vector_store(
         with PostgresStore.from_conn_string(
             conn_string,
             index=index_config,
-            ttl={"default_ttl": 2, "refresh_on_read": True} if enable_ttl else None,
         ) as store:
             store.setup()
-            with store._cursor() as cur:
-                # drop the migration index
-                cur.execute("DROP TABLE IF EXISTS store_migrations")
-            store.setup()  # Will fail if migrations aren't idempotent
             yield store
     finally:
         with Connection.connect(admin_conn_string, autocommit=True) as conn:
             conn.execute(f"DROP DATABASE {database}")
 
 
-_vector_params = [
-    (vector_type, distance_type, True)
-    for vector_type in VECTOR_TYPES
-    for distance_type in (
-        ["hamming"] if vector_type == "bit" else ["l2", "inner_product", "cosine"]
-    )
-]
-_vector_params += [(*_vector_params[-1][:2], False)]
-
-
 @pytest.fixture(
     scope="function",
-    params=_vector_params,
+    params=[
+        (vector_type, distance_type)
+        for vector_type in VECTOR_TYPES
+        for distance_type in (
+            ["hamming"] if vector_type == "bit" else ["l2", "inner_product", "cosine"]
+        )
+    ],
     ids=lambda p: f"{p[0]}_{p[1]}",
 )
 def vector_store(
@@ -443,10 +409,8 @@ def vector_store(
     fake_embeddings: Embeddings,
 ) -> PostgresStore:
     """Create a store with vector search enabled."""
-    vector_type, distance_type, enable_ttl = request.param
-    with _create_vector_store(
-        vector_type, distance_type, fake_embeddings, enable_ttl=enable_ttl
-    ) as store:
+    vector_type, distance_type = request.param
+    with _create_vector_store(vector_type, distance_type, fake_embeddings) as store:
         yield store
 
 
@@ -510,10 +474,7 @@ def test_vector_update_with_embedding(vector_store: PostgresStore) -> None:
     assert not any(r.key == "doc4" for r in results_new)
 
 
-@pytest.mark.parametrize("refresh_ttl", [True, False])
-def test_vector_search_with_filters(
-    vector_store: PostgresStore, refresh_ttl: bool
-) -> None:
+def test_vector_search_with_filters(vector_store: PostgresStore) -> None:
     """Test combining vector search with filters."""
     # Insert test documents
     docs = [
@@ -526,23 +487,16 @@ def test_vector_search_with_filters(
     for key, value in docs:
         vector_store.put(("test",), key, value)
 
-    results = vector_store.search(
-        ("test",), query="apple", filter={"color": "red"}, refresh_ttl=refresh_ttl
-    )
+    results = vector_store.search(("test",), query="apple", filter={"color": "red"})
     assert len(results) == 2
     assert results[0].key == "doc1"
 
-    results = vector_store.search(
-        ("test",), query="car", filter={"color": "red"}, refresh_ttl=refresh_ttl
-    )
+    results = vector_store.search(("test",), query="car", filter={"color": "red"})
     assert len(results) == 2
     assert results[0].key == "doc2"
 
     results = vector_store.search(
-        ("test",),
-        query="bbbbluuu",
-        filter={"score": {"$gt": 3.2}},
-        refresh_ttl=refresh_ttl,
+        ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
     )
     assert len(results) == 3
     assert results[0].key == "doc4"
@@ -734,7 +688,7 @@ def test_embed_with_path_operation_config(
         store.put(("test",), "doc5", doc5, index=False)
         results = store.search(("test",))
         assert len(results) == 3
-        assert all(r.score is None for r in results), f"{results}"
+        assert all(r.score is None for r in results)
         assert any(r.key == "doc5" for r in results)
 
         results = store.search(("test",), query="hhh")
@@ -836,27 +790,3 @@ def test_nonnull_migrations() -> None:
     for migration in PostgresStore.MIGRATIONS:
         statement = _leading_comment_remover.sub("", migration).split()[0]
         assert statement.strip()
-
-
-def test_store_ttl(store):
-    # Assumes a TTL of 1 minute = 60 seconds
-    ns = ("foo",)
-    store.put(
-        ns,
-        key="item1",
-        value={"foo": "bar"},
-        ttl=TTL_MINUTES,  # type: ignore
-    )
-    time.sleep(TTL_SECONDS - 2)
-    res = store.get(ns, key="item1", refresh_ttl=True)
-    assert res is not None
-    time.sleep(TTL_SECONDS - 2)
-    results = store.search(ns, query="foo", refresh_ttl=True)
-    assert len(results) == 1
-    time.sleep(TTL_SECONDS - 2)
-    res = store.get(ns, key="item1", refresh_ttl=False)
-    assert res is not None
-    time.sleep(TTL_SECONDS - 1)
-    # Now has been (TTL_SECONDS-2)*2 > TTL_SECONDS + TTL_SECONDS/2
-    res = store.search(ns, query="bar", refresh_ttl=False)
-    assert len(res) == 0

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

@@ -530,7 +530,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                     for idx, (channel, value) in enumerate(writes)
                 ],
             )
-            await self.conn.commit()
 
     def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         """Generate the next version ID for a channel.

libs/checkpoint-sqlite/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.6"
+version = "2.0.5"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 authors = []
 license = "MIT"

libs/checkpoint/langgraph/checkpoint/serde/base.py

@@ -45,18 +45,3 @@ def maybe_add_typed_methods(serde: SerializerProtocol) -> SerializerProtocol:
         return SerializerCompat(serde)
 
     return serde
-
-
-class CipherProtocol(Protocol):
-    """Protocol for encryption and decryption of data.
-    - `encrypt`: Encrypt plaintext.
-    - `decrypt`: Decrypt ciphertext.
-    """
-
-    def encrypt(self, plaintext: bytes) -> tuple[str, bytes]:
-        """Encrypt plaintext. Returns a tuple (cipher name, ciphertext)."""
-        ...
-
-    def decrypt(self, ciphername: str, ciphertext: bytes) -> bytes:
-        """Decrypt ciphertext. Returns the plaintext."""
-        ...

libs/checkpoint/langgraph/checkpoint/serde/encrypted.py

@@ -1,86 +0,0 @@
-import os
-from typing import Any
-
-from langgraph.checkpoint.serde.base import CipherProtocol, SerializerProtocol
-from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
-
-
-class EncryptedSerializer(SerializerProtocol):
-    """Serializer that encrypts and decrypts data using an encryption protocol."""
-
-    def __init__(
-        self, cipher: CipherProtocol, serde: SerializerProtocol = JsonPlusSerializer()
-    ) -> None:
-        self.cipher = cipher
-        self.serde = serde
-
-    def dumps(self, obj: Any) -> bytes:
-        return self.serde.dumps(obj)
-
-    def loads(self, data: bytes) -> Any:
-        return self.serde.loads(data)
-
-    def dumps_typed(self, obj: Any) -> tuple[str, bytes]:
-        """Serialize an object to a tuple (type, bytes) and encrypt the bytes."""
-        # serialize data
-        typ, data = self.serde.dumps_typed(obj)
-        # encrypt data
-        ciphername, ciphertext = self.cipher.encrypt(data)
-        # add cipher name to type
-        return f"{typ}+{ciphername}", ciphertext
-
-    def loads_typed(self, data: tuple[str, bytes]) -> Any:
-        enc_cipher, ciphertext = data
-        # unencrypted data
-        if "+" not in enc_cipher:
-            return self.serde.loads_typed(data)
-        # extract cipher name
-        typ, ciphername = enc_cipher.split("+", 1)
-        # decrypt data
-        decrypted_data = self.cipher.decrypt(ciphername, ciphertext)
-        # deserialize data
-        return self.serde.loads_typed((typ, decrypted_data))
-
-    @classmethod
-    def from_pycryptodome_aes(
-        cls, serde: SerializerProtocol = JsonPlusSerializer(), **kwargs: Any
-    ) -> "EncryptedSerializer":
-        """Create an EncryptedSerializer using AES encryption."""
-        try:
-            from Crypto.Cipher import AES  # type: ignore
-        except ImportError:
-            raise ImportError(
-                "Pycryptodome is not installed. Please install it with `pip install pycryptodome`."
-            ) from None
-
-        # check if AES key is provided
-        if "key" in kwargs:
-            key: bytes = kwargs.pop("key")
-        else:
-            key_str = os.getenv("LANGGRAPH_AES_KEY")
-            if key_str is None:
-                raise ValueError("LANGGRAPH_AES_KEY environment variable is not set.")
-            key = key_str.encode()
-            if len(key) not in (16, 24, 32):
-                raise ValueError("LANGGRAPH_AES_KEY must be 16, 24, or 32 bytes long.")
-
-        # set default mode to EAX if not provided
-        if kwargs.get("mode") is None:
-            kwargs["mode"] = AES.MODE_EAX
-
-        class PycryptodomeAesCipher(CipherProtocol):
-            def encrypt(self, plaintext: bytes) -> tuple[str, bytes]:
-                cipher = AES.new(key, **kwargs)
-                ciphertext, tag = cipher.encrypt_and_digest(plaintext)
-                return "aes", cipher.nonce + tag + ciphertext
-
-            def decrypt(self, ciphername: str, ciphertext: bytes) -> bytes:
-                assert ciphername == "aes", f"Unsupported cipher: {ciphername}"
-                nonce = ciphertext[:16]
-                tag = ciphertext[16:32]
-                actual_ciphertext = ciphertext[32:]
-
-                cipher = AES.new(key, **kwargs, nonce=nonce)
-                return cipher.decrypt_and_verify(actual_ciphertext, tag)
-
-        return cls(PycryptodomeAesCipher(), serde)

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

@@ -11,19 +11,9 @@ Core types:
 
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import (
-    Any,
-    Iterable,
-    Literal,
-    NamedTuple,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
+from typing import Any, Iterable, Literal, NamedTuple, Optional, TypedDict, Union, cast
 
 from langchain_core.embeddings import Embeddings
-from typing_extensions import override
 
 from langgraph.store.base.embed import (
     AEmbeddingsFunc,
@@ -34,20 +24,6 @@ from langgraph.store.base.embed import (
 )
 
 
-class NotProvided:
-    """Sentinel singleton."""
-
-    def __bool__(self) -> Literal[False]:
-        return False
-
-    @override
-    def __repr__(self) -> str:
-        return "NOT_GIVEN"
-
-
-NOT_PROVIDED = NotProvided()
-
-
 class Item:
     """Represents a stored item with metadata.
 
@@ -83,7 +59,7 @@ class Item:
             else created_at
         )
         self.updated_at = (
-            datetime.fromisoformat(cast(str, updated_at))
+            datetime.fromisoformat(cast(str, created_at))
             if isinstance(updated_at, str)
             else updated_at
         )
@@ -520,31 +496,6 @@ class InvalidNamespaceError(ValueError):
     """Provided namespace is invalid."""
 
 
-class TTLConfig(TypedDict, total=False):
-    """Configuration for TTL (time-to-live) behavior in the store."""
-
-    refresh_on_read: bool
-    """Default behavior for refreshing TTLs on read operations (GET and SEARCH).
-    
-    If True, TTLs will be refreshed on read operations (get/search) by default.
-    This can be overridden per-operation by explicitly setting refresh_ttl.
-    Defaults to True if not configured.
-    """
-    default_ttl: Optional[float]
-    """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]
-    """Interval in minutes between TTL sweep operations.
-    
-    If provided, the store will periodically delete expired items based on TTL.
-    Defaults to None (no sweeping).
-    """
-
-
 class IndexConfig(TypedDict, total=False):
     """Configuration for indexing documents for semantic search in the store.
 
@@ -689,8 +640,7 @@ class BaseStore(ABC):
         Subclasses must explicitly set `supports_ttl = True` to enable this feature.
     """
 
-    supports_ttl: bool = False
-    ttl_config: Optional[TTLConfig] = None
+    supports_ttl = False
 
     __slots__ = ("__weakref__",)
 
@@ -719,11 +669,7 @@ class BaseStore(ABC):
         """
 
     def get(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        *,
-        refresh_ttl: Optional[bool] = None,
+        self, namespace: tuple[str, ...], key: str, *, refresh_ttl: bool = True
     ) -> Optional[Item]:
         """Retrieve a single item.
 
@@ -731,15 +677,12 @@ class BaseStore(ABC):
             namespace: Hierarchical path for the item.
             key: Unique identifier within the namespace.
             refresh_ttl: Whether to refresh TTLs for the returned item.
-                If None (default), uses the store's default refresh_ttl setting.
                 If no TTL is specified, this argument is ignored.
 
         Returns:
             The retrieved item or None if not found.
         """
-        return self.batch(
-            [GetOp(namespace, str(key), _ensure_refresh(self.ttl_config, refresh_ttl))]
-        )[0]
+        return self.batch([GetOp(namespace, key, refresh_ttl)])[0]
 
     def search(
         self,
@@ -750,7 +693,7 @@ class BaseStore(ABC):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool = True,
     ) -> list[SearchItem]:
         """Search for items within a namespace prefix.
 
@@ -800,16 +743,7 @@ class BaseStore(ABC):
             and requires proper embedding configuration.
         """
         return self.batch(
-            [
-                SearchOp(
-                    namespace_prefix,
-                    filter,
-                    limit,
-                    offset,
-                    query,
-                    _ensure_refresh(self.ttl_config, refresh_ttl),
-                )
-            ]
+            [SearchOp(namespace_prefix, filter, limit, offset, query, refresh_ttl)]
         )[0]
 
     def put(
@@ -819,7 +753,7 @@ class BaseStore(ABC):
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: Optional[float] = None,
     ) -> None:
         """Store or update an item in the store.
 
@@ -872,22 +806,12 @@ class BaseStore(ABC):
             ```
         """
         _validate_namespace(namespace)
-        if ttl not in (NOT_PROVIDED, None) and not self.supports_ttl:
+        if ttl is not None and not self.supports_ttl:
             raise NotImplementedError(
                 f"TTL is not supported by {self.__class__.__name__}. "
                 f"Use a store implementation that supports TTL or set ttl=None."
             )
-        self.batch(
-            [
-                PutOp(
-                    namespace,
-                    str(key),
-                    value,
-                    index=index,
-                    ttl=_ensure_ttl(self.ttl_config, ttl),
-                )
-            ]
-        )
+        self.batch([PutOp(namespace, key, value, index=index, ttl=ttl)])
 
     def delete(self, namespace: tuple[str, ...], key: str) -> None:
         """Delete an item.
@@ -896,7 +820,7 @@ class BaseStore(ABC):
             namespace: Hierarchical path for the item.
             key: Unique identifier within the namespace.
         """
-        self.batch([PutOp(namespace, str(key), None, ttl=None)])
+        self.batch([PutOp(namespace, key, None, ttl=None)])
 
     def list_namespaces(
         self,
@@ -952,11 +876,7 @@ class BaseStore(ABC):
         return self.batch([op])[0]
 
     async def aget(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        *,
-        refresh_ttl: Optional[bool] = None,
+        self, namespace: tuple[str, ...], key: str, *, refresh_ttl: bool = True
     ) -> Optional[Item]:
         """Asynchronously retrieve a single item.
 
@@ -967,17 +887,7 @@ class BaseStore(ABC):
         Returns:
             The retrieved item or None if not found.
         """
-        return (
-            await self.abatch(
-                [
-                    GetOp(
-                        namespace,
-                        str(key),
-                        _ensure_refresh(self.ttl_config, refresh_ttl),
-                    )
-                ]
-            )
-        )[0]
+        return (await self.abatch([GetOp(namespace, key, refresh_ttl)]))[0]
 
     async def asearch(
         self,
@@ -988,7 +898,7 @@ class BaseStore(ABC):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool = True,
     ) -> list[SearchItem]:
         """Asynchronously search for items within a namespace prefix.
 
@@ -999,8 +909,8 @@ class BaseStore(ABC):
             limit: Maximum number of items to return.
             offset: Number of items to skip before returning results.
             refresh_ttl: Whether to refresh TTLs for the returned items.
-                If None (default), uses the store's TTLConfig.refresh_default setting.
-                If TTLConfig is not provided or no TTL is specified, this argument is ignored.
+                Defaults to True. If no TTL is specified, this argument
+                is ignored.
 
         Returns:
             List of items matching the search criteria.
@@ -1040,16 +950,7 @@ class BaseStore(ABC):
         """
         return (
             await self.abatch(
-                [
-                    SearchOp(
-                        namespace_prefix,
-                        filter,
-                        limit,
-                        offset,
-                        query,
-                        _ensure_refresh(self.ttl_config, refresh_ttl),
-                    )
-                ]
+                [SearchOp(namespace_prefix, filter, limit, offset, query, refresh_ttl)]
             )
         )[0]
 
@@ -1060,7 +961,7 @@ class BaseStore(ABC):
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: Optional[float] = None,
     ) -> None:
         """Asynchronously store or update an item in the store.
 
@@ -1121,22 +1022,12 @@ class BaseStore(ABC):
             ```
         """
         _validate_namespace(namespace)
-        if ttl not in (NOT_PROVIDED, None) and not self.supports_ttl:
+        if ttl is not None and not self.supports_ttl:
             raise NotImplementedError(
                 f"TTL is not supported by {self.__class__.__name__}. "
                 f"Use a store implementation that supports TTL or set ttl=None."
             )
-        await self.abatch(
-            [
-                PutOp(
-                    namespace,
-                    str(key),
-                    value,
-                    index=index,
-                    ttl=_ensure_ttl(self.ttl_config, ttl),
-                )
-            ]
-        )
+        await self.abatch([PutOp(namespace, key, value, index=index, ttl=ttl)])
 
     async def adelete(self, namespace: tuple[str, ...], key: str) -> None:
         """Asynchronously delete an item.
@@ -1145,7 +1036,7 @@ class BaseStore(ABC):
             namespace: Hierarchical path for the item.
             key: Unique identifier within the namespace.
         """
-        await self.abatch([PutOp(namespace, str(key), None)])
+        await self.abatch([PutOp(namespace, key, None)])
 
     async def alist_namespaces(
         self,
@@ -1225,27 +1116,6 @@ def _validate_namespace(namespace: tuple[str, ...]) -> None:
         )
 
 
-def _ensure_refresh(
-    ttl_config: Optional[TTLConfig], refresh_ttl: Optional[bool] = None
-) -> bool:
-    if refresh_ttl is not None:
-        return refresh_ttl
-    if ttl_config is not None:
-        return ttl_config.get("refresh_on_read", True)
-    return True
-
-
-def _ensure_ttl(
-    ttl_config: Optional[TTLConfig],
-    ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
-) -> Optional[float]:
-    if ttl is NOT_PROVIDED:
-        if ttl_config:
-            return ttl_config.get("default_ttl")
-        return None
-    return ttl
-
-
 __all__ = [
     "BaseStore",
     "Item",

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

@@ -5,21 +5,17 @@ from collections.abc import Iterable
 from typing import Any, Callable, Literal, Optional, TypeVar, Union
 
 from langgraph.store.base import (
-    NOT_PROVIDED,
     BaseStore,
     GetOp,
     Item,
     ListNamespacesOp,
     MatchCondition,
     NamespacePath,
-    NotProvided,
     Op,
     PutOp,
     Result,
     SearchItem,
     SearchOp,
-    _ensure_refresh,
-    _ensure_ttl,
     _validate_namespace,
 )
 
@@ -69,24 +65,11 @@ class AsyncBatchedBaseStore(BaseStore):
             pass
 
     async def aget(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        *,
-        refresh_ttl: Optional[bool] = None,
+        self, namespace: tuple[str, ...], key: str, *, refresh_ttl: bool = True
     ) -> Optional[Item]:
         assert not self._task.done()
         fut = self._loop.create_future()
-        self._aqueue.put_nowait(
-            (
-                fut,
-                GetOp(
-                    namespace,
-                    key,
-                    refresh_ttl=_ensure_refresh(self.ttl_config, refresh_ttl),
-                ),
-            )
-        )
+        self._aqueue.put_nowait((fut, GetOp(namespace, key, refresh_ttl=refresh_ttl)))
         return await fut
 
     async def asearch(
@@ -98,7 +81,7 @@ class AsyncBatchedBaseStore(BaseStore):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool = True,
     ) -> list[SearchItem]:
         assert not self._task.done()
         fut = self._loop.create_future()
@@ -111,7 +94,7 @@ class AsyncBatchedBaseStore(BaseStore):
                     limit,
                     offset,
                     query,
-                    refresh_ttl=_ensure_refresh(self.ttl_config, refresh_ttl),
+                    refresh_ttl=refresh_ttl,
                 ),
             )
         )
@@ -124,19 +107,12 @@ class AsyncBatchedBaseStore(BaseStore):
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: Optional[float] = None,
     ) -> None:
         assert not self._task.done()
         _validate_namespace(namespace)
         fut = self._loop.create_future()
-        self._aqueue.put_nowait(
-            (
-                fut,
-                PutOp(
-                    namespace, key, value, index, ttl=_ensure_ttl(self.ttl_config, ttl)
-                ),
-            )
-        )
+        self._aqueue.put_nowait((fut, PutOp(namespace, key, value, index, ttl=ttl)))
         return await fut
 
     async def adelete(
@@ -181,11 +157,7 @@ class AsyncBatchedBaseStore(BaseStore):
 
     @_check_loop
     def get(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        *,
-        refresh_ttl: Optional[bool] = None,
+        self, namespace: tuple[str, ...], key: str, *, refresh_ttl: bool = True
     ) -> Optional[Item]:
         return asyncio.run_coroutine_threadsafe(
             self.aget(namespace, key=key, refresh_ttl=refresh_ttl), self._loop
@@ -201,7 +173,7 @@ class AsyncBatchedBaseStore(BaseStore):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-        refresh_ttl: Optional[bool] = None,
+        refresh_ttl: bool = True,
     ) -> list[SearchItem]:
         return asyncio.run_coroutine_threadsafe(
             self.asearch(
@@ -223,18 +195,11 @@ class AsyncBatchedBaseStore(BaseStore):
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
         *,
-        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
+        ttl: Optional[float] = None,
     ) -> None:
         _validate_namespace(namespace)
         asyncio.run_coroutine_threadsafe(
-            self.aput(
-                namespace,
-                key=key,
-                value=value,
-                index=index,
-                ttl=_ensure_ttl(self.ttl_config, ttl),
-            ),
-            self._loop,
+            self.aput(namespace, key=key, value=value, index=index, ttl=ttl), self._loop
         ).result()
 
     @_check_loop

libs/checkpoint/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint"
-version = "2.0.21"
+version = "2.0.17"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 authors = []
 license = "MIT"

libs/checkpoint/tests/test_jsonplus.py

@@ -130,7 +130,7 @@ def test_serde_jsonplus() -> None:
             key="my-key",
             namespace=("a", "name", " "),
             created_at=datetime(2024, 9, 24, 17, 29, 10, 128397),
-            updated_at=datetime(2024, 9, 24, 17, 29, 11, 128397),
+            updated_at=datetime(2024, 9, 24, 17, 29, 10, 128397),
         ),
     }
 

libs/cli-install/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# Editor
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific
+.DS_Store
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/

libs/cli-install/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libs/cli-install/Makefile

@@ -0,0 +1,24 @@
+.PHONY: install format lint clean build publish
+
+install:
+	poetry install
+
+format:
+	poetry run ruff format langgraph_cli_install tests
+
+lint:
+	poetry run ruff check langgraph_cli_install tests
+	
+test:
+	poetry run pytest
+
+clean:
+	rm -rf dist/
+	rm -rf build/
+	rm -rf *.egg-info/
+
+build: clean
+	poetry build
+
+publish: build
+	poetry publish

libs/cli-install/README.md

@@ -0,0 +1,50 @@
+# LangGraph CLI Installer
+
+A simple installer for the LangGraph CLI that uses `uv` to create an isolated environment.
+
+## Why?
+
+This lightweight installer creates an isolated installation of LangGraph CLI without worrying about Python environment conflicts or dependencies. It uses [uv](https://github.com/astral-sh/uv) to create a standalone environment with LangGraph CLI.
+
+Key benefits:
+- Prevents conflicts with other Python packages
+- No knowledge of virtual environments needed
+- Adds to your PATH automatically
+- Installs the latest version of LangGraph CLI
+
+## Quick Install
+
+Simply run:
+
+```bash
+pip install langgraph-cli-install && langgraph-cli-install
+```
+
+This will:
+1. Install the uv package if not already installed
+2. Create an isolated environment with the latest LangGraph CLI
+3. Add the CLI to your PATH automatically
+
+After installation, you can run `langgraph --help` to get started.
+
+## How It Works
+
+This installer is similar to [aider-install](https://github.com/paul-gauthier/aider/blob/main/aider_install/main.py). It:
+
+1. Uses the `uv` Python installer to create an isolated environment
+2. Installs the latest `langgraph-cli` in that environment
+3. Adds the installed binary to your PATH
+
+This approach dramatically reduces installation issues caused by Python environment conflicts.
+
+## Manual Installation
+
+If you prefer not to use this installer, you can install LangGraph CLI directly:
+
+```bash
+pip install langgraph-cli
+```
+
+## License
+
+MIT

libs/cli-install/langgraph_cli_install/__init__.py

@@ -0,0 +1,7 @@
+"""LangGraph CLI Installer package."""
+
+__version__ = "0.1.0"
+
+from .main import main
+
+__all__ = ["main"]

libs/cli-install/langgraph_cli_install/main.py

@@ -0,0 +1,109 @@
+"""LangGraph CLI Installation Script.
+
+Main entry point for installing langgraph-cli in an isolated environment.
+This script uses uv to create an isolated installation of langgraph-cli.
+"""
+
+import platform
+import subprocess
+import sys
+
+import uv
+
+
+def main():
+    """Install langgraph-cli using uv in an isolated environment."""
+    print("Installing LangGraph CLI...")
+
+    try:
+        uv_bin = uv.find_uv_bin()
+
+        # Get best Python version for installation (prefer 3.12 if available)
+        python_version = get_latest_python_version()
+
+        # Create an isolated environment with langgraph-cli
+        print(f"Creating isolated environment using {python_version}...")
+        subprocess.check_call(
+            [
+                uv_bin,
+                "tool",
+                "install",
+                "--force",
+                "--python",
+                python_version,
+                "langgraph-cli@latest",
+            ]
+        )
+
+        # Update PATH so the tool is available
+        subprocess.check_call([uv_bin, "tool", "update-shell"])
+
+        # Show install location and help
+        show_success_message(uv_bin)
+
+    except subprocess.CalledProcessError as e:
+        print(f"\nFailed to install langgraph-cli: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nAn error occurred: {e}")
+        sys.exit(1)
+
+
+def get_latest_python_version() -> str:
+    """Get the latest compatible Python version for installation."""
+    # Try to use Python 3.13 if possible, otherwise fall back to the current version
+    target_version = "3.13"
+    try:
+        # Check if this version is available through uv
+        uv_bin = uv.find_uv_bin()
+        result = subprocess.run(
+            [uv_bin, "python", "list"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if target_version in result.stdout:
+            return f"python{target_version}"
+    except Exception:
+        pass
+
+    # Fall back to current version
+    major, minor = sys.version_info.major, sys.version_info.minor
+    return f"python{major}.{minor}"
+
+
+def show_success_message(uv_bin):
+    """Show success message and installation details."""
+    # Get installation path
+    result = subprocess.run(
+        [uv_bin, "tool", "list"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    install_path = None
+    for line in result.stdout.splitlines():
+        if "langgraph-cli" in line:
+            parts = line.strip().split()
+            if len(parts) >= 2:
+                install_path = parts[1]
+                break
+
+    # Success message
+    print("\n🎉 LangGraph CLI has been successfully installed!\n")
+    print("You can now use it by running:")
+    print("  langgraph --help")
+
+    if install_path:
+        print(f"\nInstalled at: {install_path}")
+
+    # Provide hint about shell restart if needed
+    if platform.system() != "Windows":
+        print("\nNote: You may need to restart your terminal or run:")
+        print("  source ~/.bashrc  # or ~/.zshrc depending on your shell")
+        print("to ensure the langgraph command is available in your PATH.")
+
+
+if __name__ == "__main__":
+    main()

libs/cli-install/poetry.lock

@@ -0,0 +1,44 @@
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
+
+[[package]]
+name = "packaging"
+version = "23.2"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
+    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+]
+
+[[package]]
+name = "uv"
+version = "0.1.45"
+description = "An extremely fast Python package installer and resolver, written in Rust."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "uv-0.1.45-py3-none-linux_armv6l.whl", hash = "sha256:088af576fb0e0462cd5f718d03fb1a9f16ce5ae61fdb2a9d3ea938fc826cecc1"},
+    {file = "uv-0.1.45-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b94180009264f3f7ee74250f8e4f99c8cb0cb3633e3a9c9c66cdef3eb69be575"},
+    {file = "uv-0.1.45-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4e5d55f0f8b6ae416c72d78106e224c8e8338356da21ddebecc7b1723de80924"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:7fdb235aaf420fa8ac9009999b1654a23540f03e25c35094543c2f48d7c41aef"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de81501c0b03160d0944906d1a713f108258360e20c58385974acb7253b56166"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:346aa2d0a4ad3c0c3f7852c1edf5e5a8e5d2ef34c7474e9089877291c2da979c"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:a601eed14d484d36d421e4208911a56aaf758ea6c385ef8edf8ad9f8ead57ce1"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ca2d5a5e06c5f71c7b213e14fa59129e63b77de3ffbcf84ecc98d647d73a821"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:90b68c80dddebeca69b26a2af1e2e683804bcf2b5f22d107af03d9156d6218c6"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd7f2f64fdded940342dc37234c11ae3508222c3c9b6b0eac5879dcd586010fa"},
+    {file = "uv-0.1.45-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:a39141e179fea043151a165c9155031e7976b0e4b076c0c33a45b58a420134e0"},
+    {file = "uv-0.1.45-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:68718add6ee2cef2816f9bf8a1dbf2d8cf63d98ddf45840f340029f65a49fd89"},
+    {file = "uv-0.1.45-py3-none-musllinux_1_1_i686.whl", hash = "sha256:110e0f45ddb2fe832ce50b0308be90e5439e0c02d3ffe042feeb3f759811f31f"},
+    {file = "uv-0.1.45-py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:0f6cfe885f109bacc055edd5df2c837616ae2238b9324a9d37835a96b204ab2f"},
+    {file = "uv-0.1.45-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:87e77d25e8f358c0d5de1983497ee4cf4cea8fc73373d1ef1063533352db2f89"},
+    {file = "uv-0.1.45-py3-none-win32.whl", hash = "sha256:ddb93620c9e01fa83573c2648df4bee3fa548ca940de51c8a2c3566a23a0c776"},
+    {file = "uv-0.1.45-py3-none-win_amd64.whl", hash = "sha256:8e2eeea4eec0e09f7d67378152428b5308dba8b33990d045d7a31d19bf18ca1f"},
+    {file = "uv-0.1.45.tar.gz", hash = "sha256:40fab956bc7af50dfa4bda14e5871528f57603eb9bf8595eb3144aace0ed8c47"},
+]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.8.0,<4.0"
+content-hash = "ac29a6587488fe83583561554cb37b0812f4609cf34fedc4afae8df804db0d73"

libs/cli-install/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = "langgraph-cli-install"
+version = "0.0.1-rc1"
+description = "Simple installer for langgraph-cli"
+authors = []
+license = "MIT"
+readme = "README.md"
+repository = "https://www.github.com/langchain-ai/langgraph"
+packages = [{ include = "langgraph_cli_install" }]
+
+[tool.poetry.scripts]
+langgraph-cli-install = "langgraph_cli_install.main:main"
+
+[tool.poetry.dependencies]
+python = "^3.9.0,<4.0"
+packaging = ">=23.0"
+uv = ">=0.6.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+lint.select = [
+  # pycodestyle
+  "E",
+  # Pyflakes
+  "F",
+  # pyupgrade
+  "UP",
+  # flake8-bugbear
+  "B",
+  # isort
+  "I",
+]
+lint.ignore = ["E501", "B008"]

libs/cli-install/setup.py

@@ -0,0 +1,36 @@
+"""Setup script for the langgraph-cli-install package."""
+
+from setuptools import find_packages, setup
+
+if __name__ == "__main__":
+    setup(
+        name="langgraph-cli-install",
+        version="0.1.0",
+        description="Simple installer for langgraph-cli",
+        author="",
+        author_email="",
+        license="MIT",
+        packages=find_packages(),
+        include_package_data=True,
+        entry_points={
+            "console_scripts": [
+                "langgraph-cli-install=langgraph_cli_install.main:main",
+            ],
+        },
+        python_requires=">=3.8",
+        install_requires=[
+            "uv>=0.1.24",
+            "packaging>=23.0",
+        ],
+        classifiers=[
+            "Development Status :: 4 - Beta",
+            "Intended Audience :: Developers",
+            "License :: OSI Approved :: MIT License",
+            "Programming Language :: Python :: 3",
+            "Programming Language :: Python :: 3.8",
+            "Programming Language :: Python :: 3.9",
+            "Programming Language :: Python :: 3.10",
+            "Programming Language :: Python :: 3.11",
+            "Programming Language :: Python :: 3.12",
+        ],
+    )

libs/cli-install/tests/__init__.py

@@ -0,0 +1 @@
+"""Test package for langgraph-cli-install."""

libs/cli-install/tests/test_main.py

@@ -0,0 +1,50 @@
+"""Tests for the main module."""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+from langgraph_cli_install.main import get_latest_python_version, main
+
+
+def test_get_latest_python_version():
+    """Test that the get_latest_python_version function returns a string."""
+    with patch("subprocess.run") as mock_run:
+        mock_result = MagicMock()
+        mock_result.stdout = "python3.12"
+        mock_run.return_value = mock_result
+
+        with patch("uv.find_uv_bin", return_value="/path/to/uv"):
+            version = get_latest_python_version()
+            assert isinstance(version, str)
+            assert "python" in version
+
+
+def test_get_latest_python_version_fallback():
+    """Test fallback to current version when 3.12 is not available."""
+    with patch("subprocess.run") as mock_run:
+        mock_result = MagicMock()
+        mock_result.stdout = "python3.8"  # No 3.12 here
+        mock_run.return_value = mock_result
+
+        with patch("uv.find_uv_bin", return_value="/path/to/uv"):
+            # Mock sys.version_info
+            old_version_info = sys.version_info
+            sys.version_info = MagicMock()
+            sys.version_info.major = 3
+            sys.version_info.minor = 9
+
+            try:
+                version = get_latest_python_version()
+                assert isinstance(version, str)
+                assert "python3.9" in version
+            finally:
+                # Restore original version_info
+                sys.version_info = old_version_info
+
+
+def test_main_exception():
+    """Test main function handles exceptions."""
+    with patch("uv.find_uv_bin", side_effect=Exception("Test error")):
+        with patch("sys.exit") as mock_exit:
+            main()
+            mock_exit.assert_called_once_with(1)

libs/cli-install/tests/test_version.py

@@ -0,0 +1,8 @@
+"""Test that the version is defined."""
+
+import langgraph_cli_install
+
+
+def test_version():
+    """Test that the version is defined."""
+    assert langgraph_cli_install.__version__ is not None

libs/cli/Makefile

@@ -1,4 +1,4 @@
-.PHONY: test lint format test-integration update-schema
+.PHONY: test lint format test-integration
 
 ######################
 # TESTING AND COVERAGE
@@ -31,6 +31,3 @@ lint lint_diff lint_package lint_tests:
 format format_diff:
 	poetry run ruff format $(PYTHON_FILES)
 	poetry run ruff check --select I --fix $(PYTHON_FILES)
-
-update-schema:
-	poetry run python generate_schema.py

libs/cli/langgraph_cli/config.py

@@ -11,30 +11,6 @@ MIN_NODE_VERSION = "20"
 MIN_PYTHON_VERSION = "3.11"
 
 
-class TTLConfig(TypedDict, total=False):
-    """Configuration for TTL (time-to-live) behavior in the store."""
-
-    refresh_on_read: bool
-    """Default behavior for refreshing TTLs on read operations (GET and SEARCH).
-    
-    If True, TTLs will be refreshed on read operations (get/search) by default.
-    This can be overridden per-operation by explicitly setting refresh_ttl.
-    Defaults to True if not configured.
-    """
-    default_ttl: Optional[float]
-    """Optional. Default TTL (time-to-live) in minutes for new items.
-    
-    If provided, all new items will have this TTL unless explicitly overridden.
-    If omitted, items will have no TTL by default.
-    """
-    sweep_interval_minutes: Optional[int]
-    """Optional. Interval in minutes between TTL sweep iterations.
-    
-    If provided, the store will periodically delete expired items based on the TTL.
-    If omitted, no automatic sweeping will occur.
-    """
-
-
 class IndexConfig(TypedDict, total=False):
     """Configuration for indexing documents for semantic search in the store.
 
@@ -103,13 +79,6 @@ class StoreConfig(TypedDict, total=False):
     If omitted, no vector index is initialized.
     """
 
-    ttl: Optional[TTLConfig]
-    """Optional. Defines the TTL (time-to-live) behavior configuration.
-    
-    If provided, the store will apply TTL settings according to the configuration.
-    If omitted, no TTL behavior is configured.
-    """
-
 
 class SecurityConfig(TypedDict, total=False):
     """Configuration for OpenAPI security definitions and requirements.
@@ -229,7 +198,7 @@ class CorsConfig(TypedDict, total=False):
     allow_origin_regex: str
     """Optional. A regex pattern for matching allowed origins, used if you have dynamic subdomains.
     
-    Example: "^https://.*\.mycompany\.com$"
+    Example: "^https://\\.*\\.mycompany\\.com$"
     """
     expose_headers: list[str]
     """Optional. List of headers that browsers are allowed to read from the response in cross-origin contexts."""

libs/cli/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-cli"
-version = "0.1.77"
+version = "0.1.75"
 description = "CLI for interacting with LangGraph API"
 authors = []
 license = "MIT"

libs/cli/schemas/schema.json

@@ -397,17 +397,6 @@
             }
           ],
           "description": "Optional. Defines the vector-based semantic search configuration.\n\n- Generate embeddings according to `index.embed`\n- Enforce the embedding dimension given by `index.dims`\n- Embed only specified JSON fields (if any) from `index.fields`\n\nIf omitted, no vector index is initialized.\n"
-        },
-        "ttl": {
-          "anyOf": [
-            {
-              "$ref": "#/$defs/TTLConfig"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Optional. Defines the TTL (time-to-live) behavior configuration.\n\nIf provided, the store will apply TTL settings according to the configuration.\nIf omitted, no TTL behavior is configured.\n"
         }
       },
       "required": []
@@ -441,37 +430,6 @@
         }
       },
       "required": []
-    },
-    "TTLConfig": {
-      "title": "TTLConfig",
-      "description": "Configuration for TTL (time-to-live) behavior in the store.",
-      "type": "object",
-      "properties": {
-        "default_ttl": {
-          "anyOf": [
-            {
-              "type": "number"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "refresh_on_read": {
-          "type": "boolean"
-        },
-        "sweep_interval_minutes": {
-          "anyOf": [
-            {
-              "type": "integer"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        }
-      },
-      "required": []
     }
   },
   "title": "LangGraph CLI Configuration",

libs/cli/schemas/schema.v0.json

@@ -397,17 +397,6 @@
             }
           ],
           "description": "Optional. Defines the vector-based semantic search configuration.\n\n- Generate embeddings according to `index.embed`\n- Enforce the embedding dimension given by `index.dims`\n- Embed only specified JSON fields (if any) from `index.fields`\n\nIf omitted, no vector index is initialized.\n"
-        },
-        "ttl": {
-          "anyOf": [
-            {
-              "$ref": "#/$defs/TTLConfig"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Optional. Defines the TTL (time-to-live) behavior configuration.\n\nIf provided, the store will apply TTL settings according to the configuration.\nIf omitted, no TTL behavior is configured.\n"
         }
       },
       "required": []
@@ -441,37 +430,6 @@
         }
       },
       "required": []
-    },
-    "TTLConfig": {
-      "title": "TTLConfig",
-      "description": "Configuration for TTL (time-to-live) behavior in the store.",
-      "type": "object",
-      "properties": {
-        "default_ttl": {
-          "anyOf": [
-            {
-              "type": "number"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "refresh_on_read": {
-          "type": "boolean"
-        },
-        "sweep_interval_minutes": {
-          "anyOf": [
-            {
-              "type": "integer"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        }
-      },
-      "required": []
     }
   },
   "title": "LangGraph CLI Configuration",

libs/langgraph/README.md

@@ -1,87 +1,339 @@
-<picture class="github-only">
-  <source media="(prefers-color-scheme: light)" srcset="docs/docs/static/wordmark_dark.svg">
-  <source media="(prefers-color-scheme: dark)" srcset="docs/docs/static/wordmark_light.svg">
-  <img alt="LangGraph Logo" src="docs/docs/static/wordmark_dark.svg" width="80%">
-</picture>
+# 🦜🕸️LangGraph
 
-<div>
-<br>
-</div>
-
-[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/langgraph/)
+![Version](https://img.shields.io/pypi/v/langgraph)
 [![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/)
 
+⚡ Building language agents as graphs ⚡
+
 > [!NOTE]
 > Looking for the JS version? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://langchain-ai.github.io/langgraphjs/).
 
-LangGraph — used by Replit, Uber, LinkedIn, GitLab and more — is a low-level orchestration framework for building controllable agents. While langchain provides integrations and composable components to streamline LLM application development, the LangGraph library enables agent orchestration — offering customizable architectures, long-term memory, and human-in-the-loop to reliably handle complex tasks.
+## Overview
 
-```bash
+[LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building
+stateful, multi-actor applications with LLMs, used to create agent and multi-agent
+workflows. Check out an introductory tutorial [here](https://langchain-ai.github.io/langgraph/tutorials/introduction/).
+
+
+LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+
+### Why use LangGraph?
+
+LangGraph powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
+
+- **Memory**: LangGraph persists arbitrary aspects of your application's state,
+supporting memory of conversations and other updates within and across user
+interactions;
+- **Human-in-the-loop**: Because state is checkpointed, execution can be interrupted
+and resumed, allowing for decisions, validation, and corrections at key stages via
+human input.
+
+Standardizing these components allows individuals and teams to focus on the behavior
+of their agent, instead of its supporting infrastructure.
+
+Through [LangGraph Platform](#langgraph-platform), LangGraph also provides tooling for
+the development, deployment, debugging, and monitoring of your applications.
+
+LangGraph integrates seamlessly with
+[LangChain](https://python.langchain.com/docs/introduction/) and
+[LangSmith](https://docs.smith.langchain.com/) (but does not require them).
+
+To learn more about LangGraph, check out our first LangChain Academy
+course, *Introduction to LangGraph*, available for free
+[here](https://academy.langchain.com/courses/intro-to-langgraph).
+
+### LangGraph Platform
+
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger).
+
+See deployment options [here](https://langchain-ai.github.io/langgraph/concepts/deployment_options/)
+(includes a free tier).
+
+Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+
+- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
+- **Background runs**: Runs agents asynchronously in the background
+- **Support for long running agents**: Infrastructure that can handle long running processes
+- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
+- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
+
+## Installation
+
+```shell
 pip install -U langgraph
 ```
 
-To learn more about how to use LangGraph, check out [the docs](https://langchain-ai.github.io/langgraph/). We show a simple example below of how to create a ReAct agent.
+## Example
+
+Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
+
+```shell
+pip install langchain-anthropic
+```
+
+```shell
+export ANTHROPIC_API_KEY=sk-...
+```
+
+Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
+
+```shell
+export LANGSMITH_TRACING=true
+export LANGSMITH_API_KEY=lsv2_sk_...
+```
+
+The simplest way to create a tool-calling agent in LangGraph is to use `create_react_agent`:
+
+<details open>
+  <summary>High-level implementation</summary>
 
 ```python
-# This code depends on pip install langchain[anthropic]
 from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
 
+# Define the tools for the agent to use
+@tool
 def search(query: str):
     """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
     if "sf" in query.lower() or "san francisco" in query.lower():
         return "It's 60 degrees and foggy."
     return "It's 90 degrees and sunny."
 
-agent = create_react_agent("anthropic:claude-3-7-sonnet-latest", tools=[search])
-agent.invoke(
-    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
+
+tools = [search]
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
 )
+final_state["messages"][-1].content
+```
+```
+"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
 ```
 
-## Why use LangGraph?
+Now when we pass the same <code>"thread_id"</code>, the conversation context is retained via the saved state (i.e. stored list of messages)
 
-LangGraph is built for developers who want to build powerful, adaptable AI agents. Developers choose LangGraph for:
+```python
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what about ny"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
 
-- **Reliability and controllability.** Steer agent actions with moderation checks and human-in-the-loop approvals. LangGraph persists context for long-running workflows, keeping your agents on course.
-- **Low-level and extensible.** Build custom agents with fully descriptive, low-level primitives – free from rigid abstractions that limit customization. Design scalable multi-agent systems, with each agent serving a specific role tailored to your use case.
-- **First-class streaming support.** With token-by-token streaming and streaming of intermediate steps, LangGraph gives users clear visibility into agent reasoning and actions as they unfold in real time.
+```
+"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
+```
+</details>
 
-LangGraph is trusted in production and powering agents for companies like:
+> [!TIP]
+> LangGraph is a **low-level** framework that allows you to implement any custom agent
+architectures. Click on the low-level implementation below to see how to implement a
+tool-calling agent from scratch.
 
-- [Klarna](https://blog.langchain.dev/customers-klarna/): Customer support bot for 85 million active users
-- [Elastic](https://www.elastic.co/blog/elastic-security-generative-ai-features): Security AI assistant for threat detection
-- [Uber](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/): Automated unit test generation
-- [Replit](https://www.langchain.com/breakoutagents/replit): Code generation
-- And many more ([see list here](https://www.langchain.com/built-with-langgraph))
+<details>
+<summary>Low-level implementation</summary>
 
-## LangGraph’s ecosystem
+```python
+from typing import Literal
 
-While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode
 
-- [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
-- [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/).
 
-## Pairing with LangGraph Platform
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
 
-While LangGraph is our open-source agent orchestration framework, enterprises that need scalable agent deployment can benefit from [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/).
 
-LangGraph Platform can help engineering teams:
+tools = [search]
 
-- **Accelerate agent development**: Quickly create agent UXs with configurable templates and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/) for visualizing and debugging agent interactions.
-- **Deploy seamlessly**: We handle the complexity of deploying your agent. LangGraph Platform includes robust APIs for memory, threads, and cron jobs plus auto-scaling task queues & servers.
-- **Centralize agent management & reusability**: Discover, reuse, and manage agents across the organization. Business users can also modify agents without coding.
+tool_node = ToolNode(tools)
 
-## Additional resources
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0).bind_tools(tools)
 
-- [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
-- [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Simple walkthroughs with guided examples on getting started with LangGraph.
-- [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
-- [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
-- [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
-- [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
+# Define the function that determines whether to continue or not
+def should_continue(state: MessagesState) -> Literal["tools", END]:
+    messages = state['messages']
+    last_message = messages[-1]
+    # If the LLM makes a tool call, then we route to the "tools" node
+    if last_message.tool_calls:
+        return "tools"
+    # Otherwise, we stop (reply to the user)
+    return END
 
-## Acknowledgements
 
-LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
+# Define the function that calls the model
+def call_model(state: MessagesState):
+    messages = state['messages']
+    response = model.invoke(messages)
+    # We return a list, because this will get added to the existing list
+    return {"messages": [response]}
+
+
+# Define a new graph
+workflow = StateGraph(MessagesState)
+
+# Define the two nodes we will cycle between
+workflow.add_node("agent", call_model)
+workflow.add_node("tools", tool_node)
+
+# Set the entrypoint as `agent`
+# This means that this node is the first one called
+workflow.add_edge(START, "agent")
+
+# We now add a conditional edge
+workflow.add_conditional_edges(
+    # First, we define the start node. We use `agent`.
+    # This means these are the edges taken after the `agent` node is called.
+    "agent",
+    # Next, we pass in the function that will determine which node is called next.
+    should_continue,
+)
+
+# We now add a normal edge from `tools` to `agent`.
+# This means that after `tools` is called, `agent` node is called next.
+workflow.add_edge("tools", 'agent')
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+# Finally, we compile it!
+# This compiles it into a LangChain Runnable,
+# meaning you can use it as you would any other runnable.
+# Note that we're (optionally) passing the memory when compiling the graph
+app = workflow.compile(checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+
+<b>Step-by-step Breakdown</b>:
+
+<details>
+<summary>Initialize the model and tools.</summary>
+<ul>
+  <li>
+    We use <code>ChatAnthropic</code> as our LLM. <strong>NOTE:</strong> we need to make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the <code>.bind_tools()</code> method.
+  </li>
+  <li>
+    We define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that <a href="https://python.langchain.com/docs/how_to/custom_tools/">here</a>.
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Initialize graph with state.</summary>
+
+<ul>
+    <li>We initialize graph (<code>StateGraph</code>) by passing state schema (in our case <code>MessagesState</code>)</li>
+    <li><code>MessagesState</code> is a prebuilt state schema that has one attribute -- a list of LangChain <code>Message</code> objects, as well as logic for merging the updates from each node into the state.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define graph nodes.</summary>
+
+There are two main nodes we need:
+
+<ul>
+    <li>The <code>agent</code> node: responsible for deciding what (if any) actions to take.</li>
+    <li>The <code>tools</code> node that invokes tools: if the agent decides to take an action, this node will then execute that action.</li>
+</ul>
+</details>
+
+<details>
+<summary>Define entry point and graph edges.</summary>
+
+First, we need to set the entry point for graph execution - <code>agent</code> node.
+
+Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (<code>MessagesState</code>). In our case, the destination is not known until the agent (LLM) decides.
+
+<ul>
+  <li>Conditional edge: after the agent is called, we should either:
+    <ul>
+      <li>a. Run tools if the agent said to take an action, OR</li>
+      <li>b. Finish (respond to the user) if the agent did not ask to run tools</li>
+    </ul>
+  </li>
+  <li>Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next</li>
+</ul>
+</details>
+
+<details>
+<summary>Compile the graph.</summary>
+
+<ul>
+  <li>
+    When we compile the graph, we turn it into a LangChain 
+    <a href="https://python.langchain.com/docs/concepts/runnables/">Runnable</a>, 
+    which automatically enables calling <code>.invoke()</code>, <code>.stream()</code> and <code>.batch()</code> 
+    with your inputs
+  </li>
+  <li>
+    We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, 
+    human-in-the-loop workflows, time travel and more. In our case we use <code>MemorySaver</code> - 
+    a simple in-memory checkpointer
+  </li>
+</ul>
+</details>
+
+<details>
+<summary>Execute the graph.</summary>
+
+<ol>
+  <li>LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, <code>"agent"</code>.</li>
+  <li>The <code>"agent"</code> node executes, invoking the chat model.</li>
+  <li>The chat model returns an <code>AIMessage</code>. LangGraph adds this to the state.</li>
+  <li>Graph cycles the following steps until there are no more <code>tool_calls</code> on <code>AIMessage</code>:
+    <ul>
+      <li>If <code>AIMessage</code> has <code>tool_calls</code>, <code>"tools"</code> node executes</li>
+      <li>The <code>"agent"</code> node executes again and returns <code>AIMessage</code></li>
+    </ul>
+  </li>
+  <li>Execution progresses to the special <code>END</code> value and outputs the final state. And as a result, we get a list of all our chat messages as output.</li>
+</ol>
+</details>
+
+</details>
+
+## Documentation
+
+* [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
+* [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
+* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+
+## Resources
+
+* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
+
+## Contributing
+
+For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

libs/langgraph/langgraph/graph/branch.py

@@ -1,215 +0,0 @@
-import asyncio
-from inspect import (
-    isfunction,
-    ismethod,
-    signature,
-)
-from types import FunctionType
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Hashable,
-    Literal,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Type,
-    Union,
-    cast,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
-
-from langchain_core.runnables import (
-    Runnable,
-    RunnableConfig,
-    RunnableLambda,
-)
-
-from langgraph.constants import END, START
-from langgraph.errors import InvalidUpdateError
-from langgraph.pregel.write import ChannelWrite
-from langgraph.types import Send
-from langgraph.utils.runnable import (
-    RunnableCallable,
-)
-
-
-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]]:
-    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
-        if isinstance(path, (RunnableCallable, RunnableLambda)):
-            if isfunction(path.func) or ismethod(path.func):
-                callable_ = path.func
-            elif (callable_method := getattr(path.func, "__call__", None)) and ismethod(
-                callable_method
-            ):
-                callable_ = callable_method
-            elif isfunction(path.afunc) or ismethod(path.afunc):
-                callable_ = path.afunc
-            elif (
-                callable_method := getattr(path.afunc, "__call__", None)
-            ) and ismethod(callable_method):
-                callable_ = callable_method
-        elif callable(path):
-            callable_ = path
-
-        if callable_ is not None and (hints := get_type_hints(callable_)):
-            first_parameter_name = next(
-                iter(signature(cast(FunctionType, callable_)).parameters.keys())
-            )
-            if input_hint := hints.get(first_parameter_name):
-                if isinstance(input_hint, type) and get_type_hints(input_hint):
-                    input = input_hint
-    except (TypeError, StopIteration):
-        pass
-
-    return input
-
-
-class Branch(NamedTuple):
-    path: Runnable[Any, Union[Hashable, list[Hashable]]]
-    ends: Optional[dict[Hashable, str]]
-    then: Optional[str] = None
-    input_schema: Optional[Type[Any]] = None
-
-    @classmethod
-    def from_path(
-        cls,
-        path: Runnable[Any, Union[Hashable, list[Hashable]]],
-        path_map: Optional[Union[dict[Hashable, str], list[str]]],
-        then: Optional[str] = None,
-        infer_schema: bool = False,
-    ) -> "Branch":
-        # coerce path_map to a dictionary
-        path_map_: Optional[dict[Hashable, str]] = None
-        try:
-            if isinstance(path_map, dict):
-                path_map_ = path_map.copy()
-            elif isinstance(path_map, list):
-                path_map_ = {name: name for name in path_map}
-            else:
-                # find func
-                func: Optional[Callable] = None
-                if isinstance(path, (RunnableCallable, RunnableLambda)):
-                    func = path.func or path.afunc
-                if func is not None:
-                    # find callable method
-                    if (cal := getattr(path, "__call__", None)) and ismethod(cal):
-                        func = cal
-                    # get the return type
-                    if rtn_type := get_type_hints(func).get("return"):
-                        if get_origin(rtn_type) is Literal:
-                            path_map_ = {name: name for name in get_args(rtn_type)}
-        except Exception:
-            pass
-        # infer input schema
-        input_schema = _get_branch_path_input_schema(path) if infer_schema else None
-        # create branch
-        return cls(path=path, ends=path_map_, then=then, input_schema=input_schema)
-
-    def run(
-        self,
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
-        reader: Optional[Callable[[RunnableConfig], Any]] = None,
-    ) -> RunnableCallable:
-        return ChannelWrite.register_writer(
-            RunnableCallable(
-                func=self._route,
-                afunc=self._aroute,
-                writer=writer,
-                reader=reader,
-                name=None,
-                trace=False,
-            )
-        )
-
-    def _route(
-        self,
-        input: Any,
-        config: RunnableConfig,
-        *,
-        reader: Optional[Callable[[RunnableConfig], Any]],
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
-    ) -> Runnable:
-        if reader:
-            value = reader(config)
-            # passthrough additional keys from node to branch
-            # only doable when using dict states
-            if (
-                isinstance(value, dict)
-                and isinstance(input, dict)
-                and self.input_schema is None
-            ):
-                value = {**input, **value}
-        else:
-            value = input
-        result = self.path.invoke(value, config)
-        return self._finish(writer, input, result, config)
-
-    async def _aroute(
-        self,
-        input: Any,
-        config: RunnableConfig,
-        *,
-        reader: Optional[Callable[[RunnableConfig], Any]],
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
-    ) -> Runnable:
-        if reader:
-            value = await asyncio.to_thread(reader, config)
-            # passthrough additional keys from node to branch
-            # only doable when using dict states
-            if (
-                isinstance(value, dict)
-                and isinstance(input, dict)
-                and self.input_schema is None
-            ):
-                value = {**input, **value}
-        else:
-            value = input
-        result = await self.path.ainvoke(value, config)
-        return self._finish(writer, input, result, config)
-
-    def _finish(
-        self,
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
-        input: Any,
-        result: Any,
-        config: RunnableConfig,
-    ) -> Union[Runnable, Any]:
-        if not isinstance(result, (list, tuple)):
-            result = [result]
-        if self.ends:
-            destinations: Sequence[Union[Send, str]] = [
-                r if isinstance(r, Send) else self.ends[r] for r in result
-            ]
-        else:
-            destinations = cast(Sequence[Union[Send, str]], result)
-        if any(dest is None or dest == START for dest in destinations):
-            raise ValueError("Branch did not return a valid destination")
-        if any(p.node == END for p in destinations if isinstance(p, Send)):
-            raise InvalidUpdateError("Cannot send a packet to the END node")
-        return writer(destinations, config) or input

libs/langgraph/langgraph/graph/graph.py

@@ -6,11 +6,15 @@ from typing import (
     Awaitable,
     Callable,
     Hashable,
+    Literal,
     NamedTuple,
     Optional,
     Sequence,
     Union,
     cast,
+    get_args,
+    get_origin,
+    get_type_hints,
     overload,
 )
 
@@ -30,13 +34,12 @@ from langgraph.constants import (
     TAG_HIDDEN,
     Send,
 )
-from langgraph.graph.branch import Branch
+from langgraph.errors import InvalidUpdateError
 from langgraph.pregel import Channel, Pregel
-from langgraph.pregel.protocol import PregelProtocol
 from langgraph.pregel.read import PregelNode
 from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
 from langgraph.types import All, Checkpointer
-from langgraph.utils.runnable import RunnableLike, coerce_to_runnable
+from langgraph.utils.runnable import RunnableCallable, RunnableLike, coerce_to_runnable
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +50,95 @@ class NodeSpec(NamedTuple):
     ends: Optional[Union[tuple[str, ...], dict[str, str]]] = EMPTY_SEQ
 
 
+class Branch(NamedTuple):
+    path: Runnable[Any, Union[Hashable, list[Hashable]]]
+    ends: Optional[dict[Hashable, str]]
+    then: Optional[str] = None
+
+    def run(
+        self,
+        writer: Callable[
+            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
+        ],
+        reader: Optional[Callable[[RunnableConfig], Any]] = None,
+    ) -> RunnableCallable:
+        return ChannelWrite.register_writer(
+            RunnableCallable(
+                func=self._route,
+                afunc=self._aroute,
+                writer=writer,
+                reader=reader,
+                name=None,
+                trace=False,
+            )
+        )
+
+    def _route(
+        self,
+        input: Any,
+        config: RunnableConfig,
+        *,
+        reader: Optional[Callable[[RunnableConfig], Any]],
+        writer: Callable[
+            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
+        ],
+    ) -> Runnable:
+        if reader:
+            value = reader(config)
+            # passthrough additional keys from node to branch
+            # only doable when using dict states
+            if isinstance(value, dict) and isinstance(input, dict):
+                value = {**input, **value}
+        else:
+            value = input
+        result = self.path.invoke(value, config)
+        return self._finish(writer, input, result, config)
+
+    async def _aroute(
+        self,
+        input: Any,
+        config: RunnableConfig,
+        *,
+        reader: Optional[Callable[[RunnableConfig], Any]],
+        writer: Callable[
+            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
+        ],
+    ) -> Runnable:
+        if reader:
+            value = await asyncio.to_thread(reader, config)
+            # passthrough additional keys from node to branch
+            # only doable when using dict states
+            if isinstance(value, dict) and isinstance(input, dict):
+                value = {**input, **value}
+        else:
+            value = input
+        result = await self.path.ainvoke(value, config)
+        return self._finish(writer, input, result, config)
+
+    def _finish(
+        self,
+        writer: Callable[
+            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
+        ],
+        input: Any,
+        result: Any,
+        config: RunnableConfig,
+    ) -> Union[Runnable, Any]:
+        if not isinstance(result, (list, tuple)):
+            result = [result]
+        if self.ends:
+            destinations: Sequence[Union[Send, str]] = [
+                r if isinstance(r, Send) else self.ends[r] for r in result
+            ]
+        else:
+            destinations = cast(Sequence[Union[Send, str]], result)
+        if any(dest is None or dest == START for dest in destinations):
+            raise ValueError("Branch did not return a valid destination")
+        if any(p.node == END for p in destinations if isinstance(p, Send)):
+            raise InvalidUpdateError("Cannot send a packet to the END node")
+        return writer(destinations, config) or input
+
+
 class Graph:
     def __init__(self) -> None:
         self.nodes: dict[str, NodeSpec] = {}
@@ -175,7 +267,25 @@ class Graph:
                 "Adding an edge to a graph that has already been compiled. This will "
                 "not be reflected in the compiled graph."
             )
-
+        # coerce path_map to a dictionary
+        try:
+            if isinstance(path_map, dict):
+                path_map_ = path_map.copy()
+            elif isinstance(path_map, list):
+                path_map_ = {name: name for name in path_map}
+            elif isinstance(path, Runnable):
+                path_map_ = None
+            elif rtn_type := get_type_hints(path.__call__).get(  # type: ignore[operator]
+                "return"
+            ) or get_type_hints(path).get("return"):
+                if get_origin(rtn_type) is Literal:
+                    path_map_ = {name: name for name in get_args(rtn_type)}
+                else:
+                    path_map_ = None
+            else:
+                path_map_ = None
+        except Exception:
+            path_map_ = None
         # find a name for the condition
         path = coerce_to_runnable(path, name=None, trace=True)
         name = path.name or "condition"
@@ -185,7 +295,7 @@ class Graph:
                 f"Branch with name `{path.name}` already exists for node " f"`{source}`"
             )
         # save it
-        self.branches[source][name] = Branch.from_path(path, path_map, then, False)
+        self.branches[source][name] = Branch(path, path_map_, then)
         return self
 
     def set_entry_point(self, key: str) -> Self:
@@ -420,38 +530,7 @@ class CompiledGraph(Pregel):
         *,
         xray: Union[int, bool] = False,
     ) -> DrawableGraph:
-        """Returns a drawable representation of the computation graph."""
-        from langgraph.pregel.remote import RemoteGraph
-
-        # gather subgraphs
-        if xray:
-            subpregels: dict[str, PregelProtocol] = {
-                k: v
-                async for k, v in self.aget_subgraphs()
-                if isinstance(v, (CompiledGraph, RemoteGraph))
-            }
-            subgraphs = {
-                k: v
-                for k, v in zip(
-                    subpregels,
-                    await asyncio.gather(
-                        *(
-                            p.aget_graph(
-                                config,
-                                xray=xray
-                                if isinstance(xray, bool) or xray <= 0
-                                else xray - 1,
-                            )
-                            for p in subpregels.values()
-                        )
-                    ),
-                )
-            }
-        else:
-            subgraphs = {}
-
-        # draw the graph
-        return self._draw_graph(config, subgraphs=subgraphs)
+        return self.get_graph(config, xray=xray)
 
     def get_graph(
         self,
@@ -460,36 +539,17 @@ class CompiledGraph(Pregel):
         xray: Union[int, bool] = False,
     ) -> DrawableGraph:
         """Returns a drawable representation of the computation graph."""
-        from langgraph.pregel.remote import RemoteGraph
-
-        # gather subgraphs
-        if xray:
-            subgraphs = {
-                k: v.get_graph(
-                    config,
-                    xray=xray if isinstance(xray, bool) or xray <= 0 else xray - 1,
-                )
-                for k, v in self.get_subgraphs()
-                if isinstance(v, (CompiledGraph, RemoteGraph))
-            }
-        else:
-            subgraphs = {}
-
-        # draw the graph
-        return self._draw_graph(config, subgraphs=subgraphs)
-
-    def _draw_graph(
-        self,
-        config: Optional[RunnableConfig] = None,
-        *,
-        subgraphs: dict[str, DrawableGraph] = {},
-    ) -> DrawableGraph:
-        # create the graph
         graph = DrawableGraph()
         start_nodes: dict[str, DrawableNode] = {
             START: graph.add_node(self.get_input_schema(config), START)
         }
         end_nodes: dict[str, DrawableNode] = {}
+        if xray:
+            subgraphs = {
+                k: v for k, v in self.get_subgraphs() if isinstance(v, CompiledGraph)
+            }
+        else:
+            subgraphs = {}
 
         def add_edge(
             start: str,
@@ -515,11 +575,16 @@ class CompiledGraph(Pregel):
                 metadata["__interrupt"] = "before"
             elif key in self.interrupt_after_nodes:
                 metadata["__interrupt"] = "after"
-            if key in subgraphs:
-                subgraph = subgraphs[key]
+            if xray and key in subgraphs:
+                subgraph = subgraphs[key].get_graph(
+                    config=config,
+                    xray=xray - 1
+                    if isinstance(xray, int) and not isinstance(xray, bool) and xray > 0
+                    else xray,
+                )
                 subgraph.trim_first_node()
                 subgraph.trim_last_node()
-                if len(subgraph.nodes) >= 1:
+                if len(subgraph.nodes) > 1:
                     e, s = graph.extend(subgraph, prefix=key)
                     if e is None:
                         raise ValueError(

libs/langgraph/langgraph/graph/schema_utils.py

@@ -1,162 +0,0 @@
-import logging
-import weakref
-from inspect import isclass
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    Type,
-    Union,
-    get_args,
-    get_origin,
-)
-
-from pydantic import BaseModel
-from pydantic.v1 import BaseModel as BaseModelV1
-from typing_extensions import Annotated
-
-logger = logging.getLogger(__name__)
-
-
-class SchemaCoercionMapper:
-    _cache: weakref.WeakKeyDictionary[Type[Any], dict[int, "SchemaCoercionMapper"]] = (
-        weakref.WeakKeyDictionary()
-    )
-
-    def __new__(cls, schema: Type[Any], max_depth: int = 5) -> "SchemaCoercionMapper":
-        if schema not in cls._cache:
-            cls._cache[schema] = {}
-        if max_depth in cls._cache[schema]:
-            return cls._cache[schema][max_depth]
-
-        inst = super().__new__(cls)
-        cls._cache[schema][max_depth] = inst
-        return inst
-
-    def __init__(self, schema: Type[Any], max_depth: int = 5):
-        if hasattr(self, "_inited"):
-            return
-        self._inited = True
-        self.schema = schema
-        self.max_depth = max_depth
-        if hasattr(schema, "model_fields") and hasattr(schema, "model_construct"):
-            self._fields = {n: f.annotation for n, f in schema.model_fields.items()}
-            self._construct = schema.model_construct
-        elif hasattr(schema, "__fields__") and callable(
-            getattr(schema, "construct", None)
-        ):
-            self._fields = {n: f.annotation for n, f in schema.__fields__.items()}
-            self._construct = schema.construct
-        else:
-            raise TypeError("Schema is neither valid Pydantic v1 nor v2 model.")
-        self._field_coercers: Optional[dict[str, Callable[[Any, Any], Any]]] = None
-
-    def __call__(self, input_data: Any, depth: Optional[int] = None) -> Any:
-        return self.coerce(input_data, depth)
-
-    def coerce(self, input_data: Any, depth: Optional[int] = None) -> Any:
-        if depth is None:
-            depth = self.max_depth
-        if not isinstance(input_data, dict) or depth <= 0:
-            return input_data
-        processed = {}
-        if self._field_coercers is None:
-            self._field_coercers = {
-                n: self._build_coercer(t) for n, t in self._fields.items()
-            }
-        for k, v in input_data.items():
-            fn = self._field_coercers.get(k)
-            processed[k] = fn(v, depth - 1) if fn else v
-        return self._construct(**processed)
-
-    def _build_coercer(self, field_type: Any) -> Callable[[Any, Any], Any]:
-        origin = get_origin(field_type)
-        if origin is Annotated:
-            real_type, *_ = get_args(field_type)
-            sub = self._build_coercer(real_type)
-            return lambda v, d: sub(v, d)
-        if isclass(field_type):
-            is_class_ = True
-            try:
-                is_base_model = issubclass(field_type, BaseModel)
-            except TypeError:
-                is_class_ = False
-                is_base_model = False
-
-            if is_base_model:
-                mapper = SchemaCoercionMapper(field_type, self.max_depth)
-                return lambda v, d: mapper.coerce(v, d) if isinstance(v, dict) else v
-            if is_class_ and issubclass(field_type, BaseModelV1):
-                mapper = SchemaCoercionMapper(field_type, self.max_depth)
-                return lambda v, d: mapper.coerce(v, d) if isinstance(v, dict) else v
-        if origin is list or field_type is list:
-            args = get_args(field_type)
-            if len(args) != 1:
-                return lambda v, d: v
-            sub = self._build_coercer(args[0])
-
-            def list_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, (list, tuple)):
-                    raise TypeError(f"Expected list, got {type(v).__name__}")
-                return [sub(x, d - 1) for x in v]
-
-            return list_coercer
-        if origin is dict or field_type is dict:
-            args = get_args(field_type)
-            if len(args) != 2:
-
-                def plain_dict_coercer(v: Any, d: Any) -> Any:
-                    if not isinstance(v, dict):
-                        raise TypeError(f"Expected dict, got {type(v).__name__}")
-                    return v
-
-                return plain_dict_coercer
-            k_sub = self._build_coercer(args[0])
-            v_sub = self._build_coercer(args[1])
-
-            def dict_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, dict):
-                    raise TypeError(f"Expected dict, got {type(v).__name__}")
-                return {k_sub(k, d - 1): v_sub(val, d - 1) for k, val in v.items()}
-
-            return dict_coercer
-
-        if origin is tuple:
-            targs = get_args(field_type)
-            if not targs:
-                return lambda v, d: v
-            subs = [self._build_coercer(a) for a in targs]
-
-            def tuple_coercer(v: Any, d: Any) -> Any:
-                if not isinstance(v, (list, tuple)):
-                    raise TypeError(f"Expected tuple-like, got {type(v).__name__}")
-                out = []
-                for i, sp in enumerate(subs):
-                    out.append(sp(v[i] if i < len(v) else None, d - 1))
-                return tuple(out)
-
-            return tuple_coercer
-        if origin is Union:
-            uargs = get_args(field_type)
-            subs, none_in_union = [], False
-            for arg in uargs:
-                if arg is type(None):
-                    none_in_union = True
-                else:
-                    subs.append(self._build_coercer(arg))
-
-            def union_coercer(v: Any, d: Any) -> Any:
-                if v is None and none_in_union:
-                    return None
-                err = None
-                for sp in subs:
-                    try:
-                        return sp(v, d - 1)
-                    except Exception as e:
-                        err = e
-                if err:
-                    raise err
-                return v
-
-            return union_coercer
-        return lambda v, d: v

libs/langgraph/langgraph/graph/state.py

@@ -7,9 +7,7 @@ from inspect import isclass, isfunction, ismethod, signature
 from types import FunctionType
 from typing import (
     Any,
-    Awaitable,
     Callable,
-    Hashable,
     Literal,
     NamedTuple,
     Optional,
@@ -42,15 +40,7 @@ from langgraph.errors import (
     ParentCommand,
     create_error_message,
 )
-from langgraph.graph.branch import Branch
-from langgraph.graph.graph import (
-    END,
-    START,
-    CompiledGraph,
-    Graph,
-    Send,
-)
-from langgraph.graph.schema_utils import SchemaCoercionMapper
+from langgraph.graph.graph import END, START, Branch, CompiledGraph, Graph, Send
 from langgraph.managed.base import (
     ChannelKeyPlaceholder,
     ChannelTypePlaceholder,
@@ -416,7 +406,7 @@ class StateGraph(Graph):
                         and (vals := get_args(rargs[0]))
                     ):
                         ends = vals
-        except (NameError, TypeError, StopIteration):
+        except (TypeError, StopIteration):
             pass
 
         if destinations is not None:
@@ -471,57 +461,6 @@ class StateGraph(Graph):
         self.waiting_edges.add((tuple(start_key), end_key))
         return self
 
-    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,
-        then: Optional[str] = None,
-    ) -> Self:
-        """Add a conditional edge from the starting node to any number of destination nodes.
-
-        Args:
-            source (str): The starting node. This conditional edge will run when
-                exiting this node.
-            path (Union[Callable, Runnable]): The callable that determines the next
-                node or nodes. If not specifying `path_map` it should return one or
-                more nodes. If it returns END, the graph will stop execution.
-            path_map (Optional[dict[Hashable, str]]): Optional mapping of paths to node
-                names. If omitted the paths returned by `path` should be node names.
-            then (Optional[str]): The name of a node to execute after the nodes
-                selected by `path`.
-
-        Returns:
-            Self: The instance of the graph, allowing for method chaining.
-
-        Note: Without typehints on the `path` function's return value (e.g., `-> Literal["foo", "__end__"]:`)
-            or a path_map, the graph visualization assumes the edge could transition to any node in the graph.
-
-        """  # noqa: E501
-        if self.compiled:
-            logger.warning(
-                "Adding an edge to a graph that has already been compiled. This will "
-                "not be reflected in the compiled graph."
-            )
-
-        # find a name for the condition
-        path = coerce_to_runnable(path, name=None, trace=True)
-        name = path.name or "condition"
-        # validate the condition
-        if name in self.branches[source]:
-            raise ValueError(
-                f"Branch with name `{path.name}` already exists for node " f"`{source}`"
-            )
-        # save it
-        self.branches[source][name] = Branch.from_path(path, path_map, then, True)
-        if schema := self.branches[source][name].input_schema:
-            self._add_schema(schema)
-        return self
-
     def add_sequence(
         self,
         nodes: Sequence[Union[RunnableLike, tuple[str, RunnableLike]]],
@@ -627,13 +566,6 @@ class StateGraph(Graph):
         compiled = CompiledStateGraph(
             builder=self,
             config_type=self.config_schema,
-            input_model=(
-                self.input
-                if len(self.channels) > 1
-                and isclass(self.input)
-                and issubclass(self.input, (BaseModel, BaseModelV1))
-                else None
-            ),
             nodes={},
             channels={
                 **self.channels,
@@ -762,32 +694,24 @@ class CompiledStateGraph(CompiledGraph):
                     else:
                         updates.extend(_get_updates(i) or ())
                 return updates
-            elif (t := type(input)) and get_type_hints(t):
-                # Pydantic v2
-                if isinstance(input, BaseModel):
-                    keep: Optional[set[str]] = input.model_fields_set
-                    defaults = {k: v.default for k, v in input.model_fields.items()}
-                # Pydantic v1
-                elif isinstance(input, BaseModelV1):
-                    keep = input.__fields_set__
-                    defaults = {k: v.default for k, v in t.__fields__.items()}
-                else:
-                    keep = None
-                    defaults = {}
-
-                # NOTE: This behavior for Pydantic is somewhat inelegant,
-                # but we keep around for backwards compatibility
+            elif get_type_hints(type(input)):
                 # if input is a Pydantic model, only update values
-                # that are different from the default values or in the keep set
+                # for the keys that have been explicitly set by the users
+                # (this is needed to avoid sending updates for fields with None defaults)
+                output_keys_ = output_keys
+                # Pydantic v2
+                if hasattr(input, "model_fields_set"):
+                    output_keys_ = [
+                        k for k in output_keys if k in input.model_fields_set
+                    ]
+                # Pydantic v1
+                elif hasattr(input, "__fields_set__"):
+                    output_keys_ = [k for k in output_keys if k in input.__fields_set__]
+
                 return [
-                    (k, value)
-                    for k in output_keys
-                    if (value := getattr(input, k, MISSING)) is not MISSING
-                    and (
-                        value is not None
-                        or defaults.get(k, MISSING) is not None
-                        or (keep is not None and k in keep)
-                    )
+                    (k, getattr(input, k))
+                    for k in output_keys_
+                    if getattr(input, k, MISSING) is not MISSING
                 ]
             else:
                 msg = create_error_message(
@@ -813,6 +737,7 @@ class CompiledStateGraph(CompiledGraph):
                     ChannelWrite(
                         write_entries,
                         tags=[TAG_HIDDEN],
+                        require_at_least_one_of=output_keys,
                     ),
                 ],
             )
@@ -827,7 +752,11 @@ class CompiledStateGraph(CompiledGraph):
                 # read state keys and managed values
                 channels=(list(input_values) if is_single_input else input_values),
                 # coerce state dict to schema class (eg. pydantic model)
-                mapper=_pick_mapper(list(input_values), input_schema),
+                mapper=(
+                    None
+                    if is_single_input or issubclass(input_schema, dict)
+                    else partial(_coerce_state, input_schema)
+                ),
                 writers=[
                     # publish to this channel and state keys
                     ChannelWrite(
@@ -897,12 +826,12 @@ class CompiledStateGraph(CompiledGraph):
                     config, cast(Sequence[Union[Send, ChannelWriteEntry]], writes)
                 )
 
-        schema = branch.input_schema or (
+        # attach branch publisher
+        schema = (
             self.builder.nodes[start].input
             if start in self.builder.nodes
             else self.builder.schema
         )
-        # attach branch publisher
         self.nodes[start] |= branch.run(
             branch_writer,
             _get_state_reader(self.builder, schema) if with_reader else None,
@@ -942,23 +871,14 @@ def _get_state_reader(
         select=select[0] if select == ["__root__"] else select,
         fresh=True,
         # coerce state dict to schema class (eg. pydantic model)
-        mapper=_pick_mapper(state_keys, schema),
+        mapper=(
+            None
+            if state_keys == ["__root__"] or issubclass(schema, dict)
+            else partial(_coerce_state, schema)
+        ),
     )
 
 
-def _pick_mapper(
-    state_keys: Sequence[str], schema: Type[Any]
-) -> Optional[Callable[[Any], Any]]:
-    if state_keys == ["__root__"]:
-        return None
-    if isclass(schema):
-        if issubclass(schema, dict):
-            return None
-        if issubclass(schema, (BaseModel, BaseModelV1)):
-            return SchemaCoercionMapper(schema)
-    return partial(_coerce_state, schema)
-
-
 def _coerce_state(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
     return schema(**input)
 

libs/langgraph/langgraph/pregel/__init__.py

@@ -496,8 +496,6 @@ class Pregel(PregelProtocol):
 
     config_type: Optional[Type[Any]] = None
 
-    input_model: Optional[Type[BaseModel]] = None
-
     config: Optional[RunnableConfig] = None
 
     name: str = "LangGraph"
@@ -521,7 +519,6 @@ class Pregel(PregelProtocol):
         store: Optional[BaseStore] = None,
         retry_policy: Optional[RetryPolicy] = None,
         config_type: Optional[Type[Any]] = None,
-        input_model: Optional[Type[BaseModel]] = None,
         config: Optional[RunnableConfig] = None,
         name: str = "LangGraph",
     ) -> None:
@@ -540,7 +537,6 @@ class Pregel(PregelProtocol):
         self.store = store
         self.retry_policy = retry_policy
         self.config_type = config_type
-        self.input_model = input_model
         self.config = config
         self.name = name
         if auto_validate:
@@ -654,8 +650,6 @@ class Pregel(PregelProtocol):
     def get_input_schema(
         self, config: Optional[RunnableConfig] = 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)
@@ -1973,7 +1967,6 @@ class Pregel(PregelProtocol):
                 )
             with SyncPregelLoop(
                 input,
-                input_model=self.input_model,
                 stream=StreamProtocol(stream.put, stream_modes),
                 config=config,
                 store=store,
@@ -2264,7 +2257,6 @@ class Pregel(PregelProtocol):
                 )
             async with AsyncPregelLoop(
                 input,
-                input_model=self.input_model,
                 stream=StreamProtocol(stream.put_nowait, stream_modes),
                 config=config,
                 store=store,

libs/langgraph/langgraph/pregel/algo.py

@@ -1,3 +1,4 @@
+import functools
 import itertools
 import sys
 from collections import defaultdict, deque
@@ -506,7 +507,6 @@ def prepare_single_task(
                         CONFIG_KEY_CHECKPOINT_ID: None,
                         CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
                         CONFIG_KEY_SCRATCHPAD: _scratchpad(
-                            config,
                             pending_writes,
                             task_id,
                         ),
@@ -616,7 +616,6 @@ def prepare_single_task(
                             CONFIG_KEY_CHECKPOINT_ID: None,
                             CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
                             CONFIG_KEY_SCRATCHPAD: _scratchpad(
-                                config,
                                 pending_writes,
                                 task_id,
                             ),
@@ -742,7 +741,6 @@ def prepare_single_task(
                                 CONFIG_KEY_CHECKPOINT_ID: None,
                                 CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
                                 CONFIG_KEY_SCRATCHPAD: _scratchpad(
-                                    config,
                                     pending_writes,
                                     task_id,
                                 ),
@@ -764,32 +762,12 @@ def prepare_single_task(
 
 
 def _scratchpad(
-    config: RunnableConfig,
     pending_writes: list[PendingWrite],
     task_id: str,
 ) -> PregelScratchpad:
-    # None cannot be used as a resume value, because it would be difficult to
-    # distinguish from missing when used over http
     null_resume_write = next(
         (w for w in pending_writes if w[0] == NULL_TASK_ID and w[1] == RESUME), None
     )
-    parent_scratchpad: Optional[PregelScratchpad] = config[CONF].get(
-        CONFIG_KEY_SCRATCHPAD
-    )
-
-    def get_null_resume(consume: bool = False) -> Any:
-        if null_resume_write is None:
-            if parent_scratchpad is not None:
-                return parent_scratchpad.get_null_resume(consume)
-            return None
-        if consume:
-            try:
-                pending_writes.remove(null_resume_write)
-                return null_resume_write[2]
-            except ValueError:
-                return None
-        return null_resume_write[2]
-
     # using itertools.count as an atomic counter (+= 1 is not thread-safe)
     return PregelScratchpad(
         # call
@@ -799,7 +777,10 @@ def _scratchpad(
         resume=next(
             (w[2] for w in pending_writes if w[0] == task_id and w[1] == RESUME), []
         ),
-        get_null_resume=get_null_resume,
+        null_resume=null_resume_write[2] if null_resume_write is not None else None,
+        _consume_null_resume=functools.partial(pending_writes.remove, null_resume_write)
+        if null_resume_write is not None
+        else lambda: None,
         # subgraph
         subgraph_counter=itertools.count(0).__next__,
     )

libs/langgraph/langgraph/pregel/debug.py

@@ -25,10 +25,8 @@ from langgraph.constants import (
     CONFIG_KEY_CHECKPOINT_NS,
     ERROR,
     INTERRUPT,
-    MISSING,
     NS_END,
     NS_SEP,
-    RETURN,
     TAG_HIDDEN,
 )
 from langgraph.pregel.io import read_channels
@@ -134,15 +132,8 @@ def map_debug_task_results(
             "id": task.id,
             "name": task.name,
             "error": next((w[1] for w in writes if w[0] == ERROR), None),
-            "result": [
-                w for w in writes if w[0] in stream_channels_list or w[0] == RETURN
-            ],
-            "interrupts": [
-                asdict(v)
-                for w in writes
-                if w[0] == INTERRUPT
-                for v in (w[1] if isinstance(w[1], Sequence) else [w[1]])
-            ],
+            "result": [w for w in writes if w[0] in stream_channels_list],
+            "interrupts": [asdict(w[1]) for w in writes if w[0] == INTERRUPT],
         },
     }
 
@@ -273,64 +264,49 @@ def tasks_w_writes(
 ) -> tuple[PregelTask, ...]:
     """Apply writes / subgraph states to tasks to be returned in a StateSnapshot."""
     pending_writes = pending_writes or []
-    out: list[PregelTask] = []
-    for task in tasks:
-        rtn = next(
-            (
-                val
-                for tid, chan, val in pending_writes
-                if tid == task.id and chan == RETURN
+    return tuple(
+        PregelTask(
+            task.id,
+            task.name,
+            task.path,
+            next(
+                (
+                    exc
+                    for tid, n, exc in pending_writes
+                    if tid == task.id and n == ERROR
+                ),
+                None,
             ),
-            MISSING,
-        )
-        out.append(
-            PregelTask(
-                task.id,
-                task.name,
-                task.path,
+            tuple(
+                v for tid, n, v in pending_writes if tid == task.id and n == INTERRUPT
+            ),
+            states.get(task.id) if states else None,
+            (
                 next(
                     (
-                        exc
-                        for tid, n, exc in pending_writes
-                        if tid == task.id and n == ERROR
+                        val
+                        for tid, chan, val in pending_writes
+                        if tid == task.id and chan == output_keys
                     ),
                     None,
-                ),
-                tuple(
-                    v
-                    for tid, n, vv in pending_writes
-                    if tid == task.id and n == INTERRUPT
-                    for v in (vv if isinstance(vv, Sequence) else [vv])
-                ),
-                states.get(task.id) if states else None,
-                (
-                    rtn
-                    if rtn is not MISSING
-                    else next(
-                        (
-                            val
-                            for tid, chan, val in pending_writes
-                            if tid == task.id and chan == output_keys
-                        ),
-                        None,
+                )
+                if isinstance(output_keys, str)
+                else {
+                    chan: val
+                    for tid, chan, val in pending_writes
+                    if tid == task.id
+                    and (
+                        chan == output_keys
+                        if isinstance(output_keys, str)
+                        else chan in output_keys
                     )
-                    if isinstance(output_keys, str)
-                    else {
-                        chan: val
-                        for tid, chan, val in pending_writes
-                        if tid == task.id
-                        and (
-                            chan == output_keys
-                            if isinstance(output_keys, str)
-                            else chan in output_keys
-                        )
-                    }
-                )
-                if any(
-                    w[0] == task.id and w[1] not in (ERROR, INTERRUPT)
-                    for w in pending_writes
-                )
-                else None,
+                }
             )
+            if any(
+                w[0] == task.id and w[1] not in (ERROR, INTERRUPT)
+                for w in pending_writes
+            )
+            else None,
         )
-    return tuple(out)
+        for task in tasks
+    )

libs/langgraph/langgraph/pregel/io.py

@@ -28,7 +28,7 @@ def is_task_id(task_id: str) -> bool:
     """Check if a string is a valid task id."""
     try:
         UUID(task_id)
-    except Exception:
+    except ValueError:
         return False
     return True
 

libs/langgraph/langgraph/pregel/loop.py

@@ -23,7 +23,6 @@ from typing import (
 
 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.channels.base import BaseChannel
@@ -126,7 +125,6 @@ P = ParamSpec("P")
 
 INPUT_DONE = object()
 INPUT_RESUMING = object()
-INPUT_SHOULD_VALIDATE = object()
 SPECIAL_CHANNELS = (ERROR, INTERRUPT, SCHEDULED)
 
 
@@ -141,7 +139,6 @@ def DuplexStream(*streams: StreamProtocol) -> StreamProtocol:
 
 class PregelLoop(LoopProtocol):
     input: Optional[Any]
-    input_model: Optional[Type[BaseModel]]
     checkpointer: Optional[BaseCheckpointSaver]
     nodes: Mapping[str, PregelNode]
     specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]]
@@ -205,7 +202,6 @@ class PregelLoop(LoopProtocol):
         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,
         debug: bool = False,
     ) -> None:
         super().__init__(
@@ -216,7 +212,6 @@ class PregelLoop(LoopProtocol):
             store=store,
         )
         self.input = input
-        self.input_model = input_model
         self.checkpointer = checkpointer
         self.nodes = nodes
         self.specs = specs
@@ -400,7 +395,7 @@ class PregelLoop(LoopProtocol):
         if self.status != "pending":
             raise RuntimeError("Cannot tick when status is no longer 'pending'")
 
-        if self.input not in (INPUT_DONE, INPUT_RESUMING, INPUT_SHOULD_VALIDATE):
+        if self.input not in (INPUT_DONE, INPUT_RESUMING):
             self._first(input_keys=input_keys)
         elif self.to_interrupt:
             # if we need to interrupt, do so
@@ -430,13 +425,6 @@ class PregelLoop(LoopProtocol):
             # apply writes to managed values
             for key, values in mv_writes.items():
                 self._update_mv(key, values)
-            # 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
             self._emit(
                 "values", map_output_values, self.output_keys, writes, self.channels
@@ -587,6 +575,15 @@ class PregelLoop(LoopProtocol):
             )
         )
 
+        # take resume value from parent
+        if scratchpad := cast(
+            Optional[PregelScratchpad], configurable.get(CONFIG_KEY_SCRATCHPAD)
+        ):
+            if (
+                isinstance(scratchpad, PregelScratchpad)
+                and scratchpad.null_resume is not None
+            ):
+                self.put_writes(NULL_TASK_ID, [(RESUME, scratchpad.null_resume)])
         # map command to writes
         if isinstance(self.input, Command):
             if self.input.resume is not None and not self.checkpointer:
@@ -625,8 +622,6 @@ class PregelLoop(LoopProtocol):
             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?
@@ -667,19 +662,10 @@ class PregelLoop(LoopProtocol):
             assert not mv_writes, "Can't write to SharedValues in graph input"
             # save input checkpoint
             self._put_checkpoint({"source": "input", "writes": dict(input_writes)})
-            # 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
+        # done with input
+        self.input = INPUT_RESUMING if is_resuming else INPUT_DONE
         # update config
         if not self.is_nested:
             self.config = patch_configurable(
@@ -785,14 +771,11 @@ class PregelLoop(LoopProtocol):
                     [w for t in self.tasks.values() for w in t.writes],
                     self.channels,
                 )
-            # emit INTERRUPT if exception is empty (otherwise emitted by put_writes)
-            if exc_value is not None and (not exc_value.args or not exc_value.args[0]):
-                self._emit(
-                    "updates",
-                    lambda: iter(
-                        [{INTERRUPT: cast(GraphInterrupt, exc_value).args[0]}]
-                    ),
-                )
+            # emit INTERRUPT event
+            self._emit(
+                "updates",
+                lambda: iter([{INTERRUPT: cast(GraphInterrupt, exc_value).args[0]}]),
+            )
             # save final output
             self.output = read_channels(self.channels, self.output_keys)
             # suppress interrupt
@@ -823,25 +806,7 @@ class PregelLoop(LoopProtocol):
                 "tags", EMPTY_SEQ
             ):
                 return
-            if writes[0][0] == INTERRUPT:
-                self._emit(
-                    "updates",
-                    lambda: iter(
-                        [
-                            {
-                                INTERRUPT: tuple(
-                                    v
-                                    for w in writes
-                                    if w[0] == INTERRUPT
-                                    for v in (
-                                        w[1] if isinstance(w[1], Sequence) else (w[1],)
-                                    )
-                                )
-                            }
-                        ]
-                    ),
-                )
-            elif writes[0][0] != ERROR:
+            if writes[0][0] != ERROR and writes[0][0] != INTERRUPT:
                 self._emit(
                     "updates",
                     map_output_updates,
@@ -875,12 +840,10 @@ class SyncPregelLoop(PregelLoop, ContextManager):
         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,
         debug: bool = False,
     ) -> None:
         super().__init__(
             input,
-            input_model=input_model,
             stream=stream,
             config=config,
             checkpointer=checkpointer,
@@ -1016,12 +979,10 @@ class AsyncPregelLoop(PregelLoop, AsyncContextManager):
         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,
         debug: bool = False,
     ) -> None:
         super().__init__(
             input,
-            input_model=input_model,
             stream=stream,
             config=config,
             checkpointer=checkpointer,

libs/langgraph/langgraph/pregel/read.py

@@ -201,6 +201,7 @@ class PregelNode(Runnable):
             writers[-2] = ChannelWrite(
                 writes=writers[-2].writes + writers[-1].writes,
                 tags=writers[-2].tags,
+                require_at_least_one_of=writers[-2].require_at_least_one_of,
             )
             writers.pop()
         return writers

libs/langgraph/langgraph/pregel/runner.py

@@ -543,11 +543,10 @@ class PregelRunner:
         elif exception:
             if isinstance(exception, GraphInterrupt):
                 # save interrupt to checkpointer
-                if exception.args[0]:
-                    writes = [(INTERRUPT, exception.args[0])]
+                if interrupts := [(INTERRUPT, i) for i in exception.args[0]]:
                     if resumes := [w for w in task.writes if w[0] == RESUME]:
-                        writes.extend(resumes)
-                    self.put_writes(task.id, writes)
+                        interrupts.extend(resumes)
+                    self.put_writes(task.id, interrupts)
             elif isinstance(exception, GraphBubbleUp):
                 raise exception
             else:
@@ -609,7 +608,6 @@ def _panic_or_proceed(
             done.add(fut)
         else:
             inflight.add(fut)
-    interrupts: list[GraphInterrupt] = []
     while done:
         # if any task failed
         if exc := _exception(done.pop()):
@@ -618,14 +616,7 @@ def _panic_or_proceed(
                 inflight.pop().cancel()
             # raise the exception
             if panic:
-                if isinstance(exc, GraphInterrupt):
-                    # collect interrupts
-                    interrupts.append(exc)
-                else:
-                    raise exc
-    # raise combined interrupts
-    if interrupts:
-        raise GraphInterrupt(tuple(i for exc in interrupts for i in exc.args[0]))
+                raise exc
     if inflight:
         # if we got here means we timed out
         while inflight:

libs/langgraph/langgraph/pregel/write.py

@@ -49,18 +49,21 @@ class ChannelWrite(RunnableCallable):
 
     writes: list[Union[ChannelWriteEntry, ChannelWriteTupleEntry, Send]]
     """Sequence of write entries or Send objects to write."""
+    require_at_least_one_of: Optional[Sequence[str]]
+    """If defined, at least one of these channels must be written to."""
 
     def __init__(
         self,
         writes: Sequence[Union[ChannelWriteEntry, ChannelWriteTupleEntry, Send]],
         *,
         tags: Optional[Sequence[str]] = None,
-        require_at_least_one_of: Optional[Sequence[str]] = None,  # ignored
+        require_at_least_one_of: Optional[Sequence[str]] = None,
     ):
         super().__init__(func=self._write, afunc=self._awrite, name=None, tags=tags)
         self.writes = cast(
             list[Union[ChannelWriteEntry, ChannelWriteTupleEntry, Send]], writes
         )
+        self.require_at_least_one_of = require_at_least_one_of
 
     def get_name(
         self, suffix: Optional[str] = None, *, name: Optional[str] = None
@@ -93,6 +96,7 @@ class ChannelWrite(RunnableCallable):
         self.do_write(
             config,
             writes,
+            self.require_at_least_one_of if input is not None else None,
         )
         return input
 
@@ -108,6 +112,7 @@ class ChannelWrite(RunnableCallable):
         self.do_write(
             config,
             writes,
+            self.require_at_least_one_of if input is not None else None,
         )
         return input
 
@@ -115,7 +120,7 @@ class ChannelWrite(RunnableCallable):
     def do_write(
         config: RunnableConfig,
         writes: Sequence[Union[ChannelWriteEntry, ChannelWriteTupleEntry, Send]],
-        require_at_least_one_of: Optional[Sequence[str]] = None,  # ignored
+        require_at_least_one_of: Optional[Sequence[str]] = None,
     ) -> None:
         # validate
         for w in writes:
@@ -146,6 +151,12 @@ class ChannelWrite(RunnableCallable):
                 tuples.append((w.channel, value))
             else:
                 raise ValueError(f"Invalid write entry: {w}")
+        # assert required channels
+        if require_at_least_one_of is not None:
+            if not {chan for chan, _ in tuples} & set(require_at_least_one_of):
+                raise InvalidUpdateError(
+                    f"Must write to at least one of {require_at_least_one_of}"
+                )
         write: TYPE_SEND = config[CONF][CONFIG_KEY_SEND]
         write(tuples)
 

libs/langgraph/langgraph/types.py

@@ -130,7 +130,7 @@ class Interrupt:
     value: Any
     resumable: bool = False
     ns: Optional[Sequence[str]] = None
-    when: Literal["during"] = dataclasses.field(default="during", repr=False)
+    when: Literal["during"] = "during"
 
 
 class PregelTask(NamedTuple):
@@ -140,7 +140,7 @@ class PregelTask(NamedTuple):
     error: Optional[Exception] = None
     interrupts: tuple[Interrupt, ...] = ()
     state: Union[None, RunnableConfig, "StateSnapshot"] = None
-    result: Optional[Any] = None
+    result: Optional[dict[str, Any]] = None
 
 
 class PregelExecutableTask(NamedTuple):
@@ -351,11 +351,20 @@ class PregelScratchpad:
     call_counter: Callable[[], int]
     # interrupt
     interrupt_counter: Callable[[], int]
-    get_null_resume: Callable[[bool], Any]
     resume: list[Any]
+    null_resume: Optional[Any]
+    _consume_null_resume: Callable[[], None]
     # subgraph
     subgraph_counter: Callable[[], int]
 
+    def consume_null_resume(self) -> Any:
+        if self.null_resume is not None:
+            value = self.null_resume
+            self._consume_null_resume()
+            self.null_resume = None
+            return value
+        raise ValueError("No null resume to consume")
+
 
 def interrupt(value: Any) -> Any:
     """Interrupt the graph with a resumable exception from within a node.
@@ -471,9 +480,9 @@ def interrupt(value: Any) -> Any:
         if idx < len(scratchpad.resume):
             return scratchpad.resume[idx]
     # find current resume value
-    v = scratchpad.get_null_resume(True)
-    if v is not None:
+    if scratchpad.null_resume is not None:
         assert len(scratchpad.resume) == idx, (scratchpad.resume, idx)
+        v = scratchpad.consume_null_resume()
         scratchpad.resume.append(v)
         conf[CONFIG_KEY_SEND]([(RESUME, scratchpad.resume)])
         return v

libs/langgraph/langgraph/utils/config.py

@@ -1,5 +1,4 @@
 from collections import ChainMap
-from os import getenv
 from typing import Any, Optional, Sequence, cast
 
 from langchain_core.callbacks import (
@@ -12,6 +11,7 @@ from langchain_core.runnables import RunnableConfig
 from langchain_core.runnables.config import (
     CONFIG_KEYS,
     COPIABLE_KEYS,
+    DEFAULT_RECURSION_LIMIT,
     var_child_runnable_config,
 )
 
@@ -26,8 +26,6 @@ from langgraph.constants import (
     NS_SEP,
 )
 
-DEFAULT_RECURSION_LIMIT = int(getenv("LANGGRAPH_DEFAULT_RECURSION_LIMIT", "25"))
-
 
 def recast_checkpoint_ns(ns: str) -> str:
     """Remove task IDs from checkpoint namespace.

libs/langgraph/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.0.0 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
 
 [[package]]
 name = "aiosqlite"
@@ -1324,19 +1324,19 @@ files = [
 
 [[package]]
 name = "langchain-core"
-version = "0.3.44"
+version = "0.3.30"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["main", "dev"]
 files = [
-    {file = "langchain_core-0.3.44-py3-none-any.whl", hash = "sha256:d989ce8bd62f1d07765acd575e6ec1254aec0cf7775aaea39fe4af8102377459"},
-    {file = "langchain_core-0.3.44.tar.gz", hash = "sha256:7c0a01e78360f007cbca448178fe7e032404068e6431dbe8ce905f84febbdfa5"},
+    {file = "langchain_core-0.3.30-py3-none-any.whl", hash = "sha256:0a4c4e02fac5968b67fbb0142c00c2b976c97e45fce62c7ac9eb1636a6926493"},
+    {file = "langchain_core-0.3.30.tar.gz", hash = "sha256:0f1281b4416977df43baf366633ad18e96c5dcaaeae6fcb8a799f9889c853243"},
 ]
 
 [package.dependencies]
 jsonpatch = ">=1.33,<2.0"
-langsmith = ">=0.1.125,<0.4"
+langsmith = ">=0.1.125,<0.3"
 packaging = ">=23.2,<25"
 pydantic = [
     {version = ">=2.5.2,<3.0.0", markers = "python_full_version < \"3.12.4\""},
@@ -1348,7 +1348,7 @@ typing-extensions = ">=4.7"
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "2.0.18"
+version = "2.0.16"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -1366,7 +1366,7 @@ url = "../checkpoint"
 
 [[package]]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.16"
+version = "2.0.15"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -1386,7 +1386,7 @@ url = "../checkpoint-postgres"
 
 [[package]]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.6"
+version = "2.0.5"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0"
@@ -1404,7 +1404,7 @@ url = "../checkpoint-sqlite"
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.1.2"
+version = "0.1.1"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -1422,7 +1422,7 @@ url = "../prebuilt"
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.55"
+version = "0.1.53"
 description = "SDK for interacting with LangGraph API"
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -2238,48 +2238,6 @@ files = [
     {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"},
 ]
 
-[[package]]
-name = "pycryptodome"
-version = "3.21.0"
-description = "Cryptographic library for Python"
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"
-groups = ["dev"]
-files = [
-    {file = "pycryptodome-3.21.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:dad9bf36eda068e89059d1f07408e397856be9511d7113ea4b586642a429a4fd"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:a1752eca64c60852f38bb29e2c86fca30d7672c024128ef5d70cc15868fa10f4"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:3ba4cc304eac4d4d458f508d4955a88ba25026890e8abff9b60404f76a62c55e"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cb087b8612c8a1a14cf37dd754685be9a8d9869bed2ffaaceb04850a8aeef7e"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-musllinux_1_1_aarch64.whl", hash = "sha256:26412b21df30b2861424a6c6d5b1d8ca8107612a4cfa4d0183e71c5d200fb34a"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-win32.whl", hash = "sha256:cc2269ab4bce40b027b49663d61d816903a4bd90ad88cb99ed561aadb3888dd3"},
-    {file = "pycryptodome-3.21.0-cp27-cp27m-win_amd64.whl", hash = "sha256:0fa0a05a6a697ccbf2a12cec3d6d2650b50881899b845fac6e87416f8cb7e87d"},
-    {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6cce52e196a5f1d6797ff7946cdff2038d3b5f0aba4a43cb6bf46b575fd1b5bb"},
-    {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:a915597ffccabe902e7090e199a7bf7a381c5506a747d5e9d27ba55197a2c568"},
-    {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4e74c522d630766b03a836c15bff77cb657c5fdf098abf8b1ada2aebc7d0819"},
-    {file = "pycryptodome-3.21.0-cp27-cp27mu-musllinux_1_1_aarch64.whl", hash = "sha256:a3804675283f4764a02db05f5191eb8fec2bb6ca34d466167fc78a5f05bbe6b3"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-macosx_10_9_universal2.whl", hash = "sha256:2480ec2c72438430da9f601ebc12c518c093c13111a5c1644c82cdfc2e50b1e4"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:de18954104667f565e2fbb4783b56667f30fb49c4d79b346f52a29cb198d5b6b"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2de4b7263a33947ff440412339cb72b28a5a4c769b5c1ca19e33dd6cd1dcec6e"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0714206d467fc911042d01ea3a1847c847bc10884cf674c82e12915cfe1649f8"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d85c1b613121ed3dbaa5a97369b3b757909531a959d229406a75b912dd51dd1"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:8898a66425a57bcf15e25fc19c12490b87bd939800f39a03ea2de2aea5e3611a"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_2_i686.whl", hash = "sha256:932c905b71a56474bff8a9c014030bc3c882cee696b448af920399f730a650c2"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:18caa8cfbc676eaaf28613637a89980ad2fd96e00c564135bf90bc3f0b34dd93"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-win32.whl", hash = "sha256:280b67d20e33bb63171d55b1067f61fbd932e0b1ad976b3a184303a3dad22764"},
-    {file = "pycryptodome-3.21.0-cp36-abi3-win_amd64.whl", hash = "sha256:b7aa25fc0baa5b1d95b7633af4f5f1838467f1815442b22487426f94e0d66c53"},
-    {file = "pycryptodome-3.21.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:2cb635b67011bc147c257e61ce864879ffe6d03342dc74b6045059dfbdedafca"},
-    {file = "pycryptodome-3.21.0-pp27-pypy_73-win32.whl", hash = "sha256:4c26a2f0dc15f81ea3afa3b0c87b87e501f235d332b7f27e2225ecb80c0b1cdd"},
-    {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d5ebe0763c982f069d3877832254f64974139f4f9655058452603ff559c482e8"},
-    {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ee86cbde706be13f2dec5a42b52b1c1d1cbb90c8e405c68d0755134735c8dc6"},
-    {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0fd54003ec3ce4e0f16c484a10bc5d8b9bd77fa662a12b85779a2d2d85d67ee0"},
-    {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5dfafca172933506773482b0e18f0cd766fd3920bd03ec85a283df90d8a17bc6"},
-    {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:590ef0898a4b0a15485b05210b4a1c9de8806d3ad3d47f74ab1dc07c67a6827f"},
-    {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f35e442630bc4bc2e1878482d6f59ea22e280d7121d7adeaedba58c23ab6386b"},
-    {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff99f952db3db2fbe98a0b355175f93ec334ba3d01bbde25ad3a5a33abc02b58"},
-    {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8acd7d34af70ee63f9a849f957558e49a98f8f1634f86a59d2be62bb8e93f71c"},
-    {file = "pycryptodome-3.21.0.tar.gz", hash = "sha256:f7787e0d469bdae763b876174cf2e6c0f7be79808af26b1da96f1a64bcf47297"},
-]
-
 [[package]]
 name = "pydantic"
 version = "2.9.2"
@@ -3551,4 +3509,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.9.0,<4.0"
-content-hash = "b8641a0b2d92bee0363602e69f99b23366b2035b7e17ff017708194e6fbd0ac5"
+content-hash = "eb85f0bcc0e8a715ef38afb58cf888f7c2ee8579ea6ed94900244365f24cddd9"

libs/langgraph/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph"
-version = "0.3.14"
+version = "0.3.5"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 license = "MIT"
@@ -37,7 +37,6 @@ uvloop = "0.21.0beta1"
 pyperf = "^2.7.0"
 py-spy = "^0.3.14"
 types-requests = "^2.32.0.20240914"
-pycryptodome = "^3.21.0"
 
 [tool.ruff]
 lint.select = [ "E", "F", "I", "TID251" ]

libs/langgraph/tests/__snapshots__/test_large_cases_async.ambr

@@ -6,6 +6,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -14,8 +16,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2
@@ -31,6 +31,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -39,8 +41,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2
@@ -56,6 +56,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -64,8 +66,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2
@@ -81,6 +81,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -89,8 +91,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2
@@ -106,6 +106,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -114,8 +116,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2
@@ -131,6 +131,8 @@
   	__start__([<p>__start__</p>]):::first
   	router_node(router_node)
   	normal_llm_node(normal_llm_node)
+  	weather_graph_model_node(model_node)
+  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> router_node;
   	normal_llm_node --> __end__;
@@ -139,8 +141,6 @@
   	router_node -.-> weather_graph_model_node;
   	router_node -.-> __end__;
   	subgraph weather_graph
-  	weather_graph_model_node(model_node)
-  	weather_graph_weather_node(weather_node<hr/><small><em>__interrupt = before</em></small>)
   	weather_graph_model_node --> weather_graph_weather_node;
   	end
   	classDef default fill:#f2f0ff,line-height:1.2

libs/langgraph/tests/__snapshots__/test_pregel.ambr

@@ -377,19 +377,6 @@
   
   '''
 # ---
-# name: test_in_one_fan_out_state_graph_waiting_edge[sqlite_aes]
-  '''
-  graph TD;
-  	__start__ --> rewrite_query;
-  	analyzer_one --> retriever_one;
-  	qa --> __end__;
-  	retriever_one --> qa;
-  	retriever_two --> qa;
-  	rewrite_query --> analyzer_one;
-  	rewrite_query --> retriever_two;
-  
-  '''
-# ---
 # name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1[memory]
   '''
   graph TD;
@@ -810,76 +797,6 @@
     'type': 'object',
   })
 # ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1[sqlite_aes]
-  '''
-  graph TD;
-  	__start__ --> rewrite_query;
-  	analyzer_one --> retriever_one;
-  	qa --> __end__;
-  	retriever_one --> qa;
-  	retriever_two --> qa;
-  	rewrite_query --> analyzer_one;
-  	rewrite_query -.-> retriever_two;
-  
-  '''
-# ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1[sqlite_aes].1
-  dict({
-    'definitions': dict({
-      'InnerObject': dict({
-        'properties': dict({
-          'yo': dict({
-            'title': 'Yo',
-            'type': 'integer',
-          }),
-        }),
-        'required': list([
-          'yo',
-        ]),
-        'title': 'InnerObject',
-        'type': 'object',
-      }),
-    }),
-    'properties': dict({
-      'inner': dict({
-        '$ref': '#/definitions/InnerObject',
-      }),
-      'query': dict({
-        'title': 'Query',
-        'type': 'string',
-      }),
-    }),
-    'required': list([
-      'query',
-      'inner',
-    ]),
-    'title': 'Input',
-    'type': 'object',
-  })
-# ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1[sqlite_aes].2
-  dict({
-    'properties': dict({
-      'answer': dict({
-        'title': 'Answer',
-        'type': 'string',
-      }),
-      'docs': dict({
-        'items': dict({
-          'type': 'string',
-        }),
-        'title': 'Docs',
-        'type': 'array',
-      }),
-    }),
-    'required': list([
-      'answer',
-      'docs',
-    ]),
-    'title': 'Output',
-    'type': 'object',
-  })
-# ---
 # name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2[memory]
   '''
   graph TD;
@@ -1300,76 +1217,6 @@
     'type': 'object',
   })
 # ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2[sqlite_aes]
-  '''
-  graph TD;
-  	__start__ --> rewrite_query;
-  	analyzer_one --> retriever_one;
-  	qa --> __end__;
-  	retriever_one --> qa;
-  	retriever_two --> qa;
-  	rewrite_query --> analyzer_one;
-  	rewrite_query -.-> retriever_two;
-  
-  '''
-# ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2[sqlite_aes].1
-  dict({
-    '$defs': dict({
-      'InnerObject': dict({
-        'properties': dict({
-          'yo': dict({
-            'title': 'Yo',
-            'type': 'integer',
-          }),
-        }),
-        'required': list([
-          'yo',
-        ]),
-        'title': 'InnerObject',
-        'type': 'object',
-      }),
-    }),
-    'properties': dict({
-      'inner': dict({
-        '$ref': '#/$defs/InnerObject',
-      }),
-      'query': dict({
-        'title': 'Query',
-        'type': 'string',
-      }),
-    }),
-    'required': list([
-      'query',
-      'inner',
-    ]),
-    'title': 'Input',
-    'type': 'object',
-  })
-# ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2[sqlite_aes].2
-  dict({
-    'properties': dict({
-      'answer': dict({
-        'title': 'Answer',
-        'type': 'string',
-      }),
-      'docs': dict({
-        'items': dict({
-          'type': 'string',
-        }),
-        'title': 'Docs',
-        'type': 'array',
-      }),
-    }),
-    'required': list([
-      'answer',
-      'docs',
-    ]),
-    'title': 'Output',
-    'type': 'object',
-  })
-# ---
 # name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic_input[memory]
   '''
   graph TD;
@@ -1868,19 +1715,6 @@
   
   '''
 # ---
-# name: test_in_one_fan_out_state_graph_waiting_edge_via_branch[sqlite_aes]
-  '''
-  graph TD;
-  	__start__ --> rewrite_query;
-  	analyzer_one --> retriever_one;
-  	qa --> __end__;
-  	retriever_one --> qa;
-  	retriever_two --> qa;
-  	rewrite_query --> analyzer_one;
-  	rewrite_query -.-> retriever_two;
-  
-  '''
-# ---
 # name: test_multiple_sinks_subgraphs
   '''
   %%{init: {'flowchart': {'curve': 'linear'}}}%%
@@ -1888,13 +1722,13 @@
   	__start__([<p>__start__</p>]):::first
   	uno(uno)
   	dos(dos)
+  	subgraph_one(one)
+  	subgraph_two(two)
+  	subgraph_three(three)
   	__start__ --> uno;
   	uno -.-> dos;
   	uno -.-> subgraph_one;
   	subgraph subgraph
-  	subgraph_one(one)
-  	subgraph_two(two)
-  	subgraph_three(three)
   	subgraph_one -.-> subgraph_two;
   	subgraph_one -.-> subgraph_three;
   	end
@@ -1918,14 +1752,12 @@
   %%{init: {'flowchart': {'curve': 'linear'}}}%%
   graph TD;
   	__start__([<p>__start__</p>]):::first
+  	inner(inner)
   	side(side)
   	__end__([<p>__end__</p>]):::last
-  	__start__ --> inner_up;
-  	inner_up --> side;
+  	__start__ --> inner;
+  	inner --> side;
   	side --> __end__;
-  	subgraph inner
-  	inner_up(up)
-  	end
   	classDef default fill:#f2f0ff,line-height:1.2
   	classDef first fill-opacity:0
   	classDef last fill:#bfb6fc
@@ -2063,6 +1895,10 @@
   graph TD;
   	__start__([<p>__start__</p>]):::first
   	tool_one(tool_one)
+  	tool_two___start__(<p>__start__</p>)
+  	tool_two_tool_two_slow(tool_two_slow)
+  	tool_two_tool_two_fast(tool_two_fast)
+  	tool_two___end__(<p>__end__</p>)
   	tool_three(tool_three)
   	__end__([<p>__end__</p>]):::last
   	__start__ -.-> tool_one;
@@ -2072,10 +1908,6 @@
   	__start__ -.-> tool_three;
   	tool_three --> __end__;
   	subgraph tool_two
-  	tool_two___start__(<p>__start__</p>)
-  	tool_two_tool_two_slow(tool_two_slow)
-  	tool_two_tool_two_fast(tool_two_fast)
-  	tool_two___end__(<p>__end__</p>)
   	tool_two___start__ -.-> tool_two_tool_two_slow;
   	tool_two_tool_two_slow --> tool_two___end__;
   	tool_two___start__ -.-> tool_two_tool_two_fast;
@@ -2130,24 +1962,24 @@
   graph TD;
   	__start__([<p>__start__</p>]):::first
   	gp_one(gp_one)
+  	gp_two___start__(<p>__start__</p>)
+  	gp_two_p_one(p_one)
+  	gp_two_p_two___start__(<p>__start__</p>)
+  	gp_two_p_two_c_one(c_one)
+  	gp_two_p_two_c_two(c_two)
+  	gp_two_p_two___end__(<p>__end__</p>)
+  	gp_two___end__(<p>__end__</p>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> gp_one;
   	gp_two___end__ --> gp_one;
   	gp_one -. &nbsp;0&nbsp; .-> gp_two___start__;
   	gp_one -. &nbsp;1&nbsp; .-> __end__;
   	subgraph gp_two
-  	gp_two___start__(<p>__start__</p>)
-  	gp_two_p_one(p_one)
-  	gp_two___end__(<p>__end__</p>)
   	gp_two___start__ --> gp_two_p_one;
   	gp_two_p_two___end__ --> gp_two_p_one;
   	gp_two_p_one -. &nbsp;0&nbsp; .-> gp_two_p_two___start__;
   	gp_two_p_one -. &nbsp;1&nbsp; .-> gp_two___end__;
   	subgraph p_two
-  	gp_two_p_two___start__(<p>__start__</p>)
-  	gp_two_p_two_c_one(c_one)
-  	gp_two_p_two_c_two(c_two)
-  	gp_two_p_two___end__(<p>__end__</p>)
   	gp_two_p_two___start__ --> gp_two_p_two_c_one;
   	gp_two_p_two_c_two --> gp_two_p_two_c_one;
   	gp_two_p_two_c_one -. &nbsp;0&nbsp; .-> gp_two_p_two_c_two;
@@ -2166,16 +1998,16 @@
   graph TD;
   	__start__([<p>__start__</p>]):::first
   	p_one(p_one)
+  	p_two___start__(<p>__start__</p>)
+  	p_two_c_one(c_one)
+  	p_two_c_two(c_two)
+  	p_two___end__(<p>__end__</p>)
   	__end__([<p>__end__</p>]):::last
   	__start__ --> p_one;
   	p_two___end__ --> p_one;
   	p_one -. &nbsp;0&nbsp; .-> p_two___start__;
   	p_one -. &nbsp;1&nbsp; .-> __end__;
   	subgraph p_two
-  	p_two___start__(<p>__start__</p>)
-  	p_two_c_one(c_one)
-  	p_two_c_two(c_two)
-  	p_two___end__(<p>__end__</p>)
   	p_two___start__ --> p_two_c_one;
   	p_two_c_two --> p_two_c_one;
   	p_two_c_one -. &nbsp;0&nbsp; .-> p_two_c_two;

libs/langgraph/tests/conftest.py

@@ -16,7 +16,6 @@ from langgraph.checkpoint.postgres.aio import (
     AsyncPostgresSaver,
     AsyncShallowPostgresSaver,
 )
-from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
 from langgraph.checkpoint.sqlite import SqliteSaver
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.store.base import BaseStore
@@ -62,15 +61,6 @@ def checkpointer_sqlite():
         yield checkpointer
 
 
-@pytest.fixture(scope="function")
-def checkpointer_sqlite_aes():
-    with SqliteSaver.from_conn_string(":memory:") as checkpointer:
-        checkpointer.serde = EncryptedSerializer.from_pycryptodome_aes(
-            key=b"1234567890123456"
-        )
-        yield checkpointer
-
-
 @asynccontextmanager
 async def _checkpointer_sqlite_aio():
     async with AsyncSqliteSaver.from_conn_string(":memory:") as checkpointer:
@@ -447,7 +437,6 @@ REGULAR_CHECKPOINTERS_SYNC = [
     "postgres",
     "postgres_pipe",
     "postgres_pool",
-    "sqlite_aes",
 ]
 ALL_CHECKPOINTERS_SYNC = [
     *REGULAR_CHECKPOINTERS_SYNC,

libs/langgraph/tests/test_large_cases.py

@@ -2827,7 +2827,7 @@ def test_state_graph_packets(
         }
 
     # Define decision-making logic
-    def should_continue(data: dict) -> str:
+    def should_continue(data: AgentState) -> str:
         assert isinstance(data["session"], httpx.Client)
         assert (
             data["something_extra"] == "hi there"

libs/langgraph/tests/test_pregel.py

@@ -2607,7 +2607,7 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1(
             arbitrary_types_allowed = True
 
         query: str
-        inner: Annotated[InnerObject, lambda x, y: y]
+        inner: InnerObject
         answer: Optional[str] = None
         docs: Annotated[list[str], sorted_add]
         client: Annotated[httpx.Client, Context(make_httpx_client)]
@@ -2625,15 +2625,10 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1(
         answer: Optional[str] = None
         docs: Optional[list[str]] = None
 
-    class UpdateDocs34(BaseModel):
-        docs: list[str] = ["doc3", "doc4"]
-
     def rewrite_query(data: State) -> State:
-        assert isinstance(data.inner, InnerObject)
         return {"query": f"query: {data.query}"}
 
     def analyzer_one(data: State) -> State:
-        assert isinstance(data.inner, InnerObject)
         return StateUpdate(query=f"analyzed: {data.query}")
 
     def retriever_one(data: State) -> State:
@@ -2641,7 +2636,7 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic1(
 
     def retriever_two(data: State) -> State:
         time.sleep(0.1)
-        return UpdateDocs34()
+        return {"docs": ["doc3", "doc4"]}
 
     def qa(data: State) -> State:
         return {"answer": ",".join(data.docs)}
@@ -2737,7 +2732,7 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
     request: pytest.FixtureRequest,
     checkpointer_name: str,
 ) -> None:
-    from pydantic import BaseModel, ConfigDict, Field, ValidationError
+    from pydantic import BaseModel, ConfigDict, ValidationError
 
     checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
     setup = mocker.Mock()
@@ -2780,7 +2775,7 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
         model_config = ConfigDict(arbitrary_types_allowed=True)
 
         query: str
-        inner: Annotated[InnerObject, lambda x, y: y]
+        inner: InnerObject
         answer: Optional[str] = None
         docs: Annotated[list[str], sorted_add]
         client: Annotated[httpx.Client, Context(make_httpx_client)]
@@ -2790,9 +2785,6 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
         answer: Optional[str] = None
         docs: Optional[list[str]] = None
 
-    class UpdateDocs34(BaseModel):
-        docs: list[str] = Field(default_factory=lambda: ["doc3", "doc4"])
-
     class Input(BaseModel):
         query: str
         inner: InnerObject
@@ -2802,11 +2794,9 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
         docs: list[str]
 
     def rewrite_query(data: State) -> State:
-        assert isinstance(data.inner, InnerObject)
         return {"query": f"query: {data.query}"}
 
     def analyzer_one(data: State) -> State:
-        assert isinstance(data.inner, InnerObject)
         return StateUpdate(query=f"analyzed: {data.query}")
 
     def retriever_one(data: State) -> State:
@@ -2814,7 +2804,7 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
 
     def retriever_two(data: State) -> State:
         time.sleep(0.1)
-        return UpdateDocs34()
+        return {"docs": ["doc3", "doc4"]}
 
     def qa(data: State) -> State:
         return {"answer": ",".join(data.docs)}
@@ -3037,123 +3027,6 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic_inp
     }
 
 
-@pytest.mark.parametrize("version", ["v1", "v2"])
-def test_nested_pydantic_models(version: str) -> None:
-    """Test that nested Pydantic models are properly constructed from leaf nodes up."""
-
-    # Define nested Pydantic models
-    if version == "v1":
-        from pydantic.v1 import BaseModel, Field
-    else:
-        from pydantic import BaseModel, Field
-
-    class NestedModel(BaseModel):
-        value: int
-        name: str
-
-    # Forward reference model
-    class RecursiveModel(BaseModel):
-        value: str
-        child: Optional["RecursiveModel"] = None
-
-    # Discriminated union models
-    class Cat(BaseModel):
-        pet_type: Literal["cat"]
-        meow: str
-
-    class Dog(BaseModel):
-        pet_type: Literal["dog"]
-        bark: str
-
-    # Cyclic reference model
-    class Person(BaseModel):
-        id: str
-        name: str
-        friends: list[str] = Field(default_factory=list)  # IDs of friends
-
-    class State(BaseModel):
-        # Basic nested model tests
-        top_level: str
-        nested: NestedModel
-        optional_nested: Annotated[Optional[NestedModel], lambda x, y: y, "Foo"]
-        dict_nested: dict[str, NestedModel]
-        list_nested: Annotated[
-            Union[dict, list[dict[str, NestedModel]]], lambda x, y: (x or []) + [y]
-        ]
-        tuple_nested: tuple[str, NestedModel]
-        tuple_list_nested: list[tuple[int, NestedModel]]
-        complex_tuple: tuple[str, dict[str, tuple[int, NestedModel]]]
-
-        # Forward reference test
-        recursive: RecursiveModel
-
-        # Discriminated union test
-        pet: Union[Cat, Dog]
-
-        # Cyclic reference test
-        people: dict[str, Person]  # Map of ID -> Person
-
-    inputs = {
-        # Basic nested models
-        "top_level": "initial",
-        "nested": {"value": 42, "name": "test"},
-        "optional_nested": {"value": 10, "name": "optional"},
-        "dict_nested": {"a": {"value": 5, "name": "a"}},
-        "list_nested": [{"a": {"value": 6, "name": "b"}}],
-        "tuple_nested": ["tuple-key", {"value": 7, "name": "tuple-value"}],
-        "tuple_list_nested": [[1, {"value": 8, "name": "tuple-in-list"}]],
-        "complex_tuple": [
-            "complex",
-            {"nested": [9, {"value": 10, "name": "deep"}]},
-        ],
-        # Forward reference
-        "recursive": {"value": "parent", "child": {"value": "child", "child": None}},
-        # Discriminated union (using a cat in this case)
-        "pet": {"pet_type": "cat", "meow": "meow!"},
-        # Cyclic references
-        "people": {
-            "1": {
-                "id": "1",
-                "name": "Alice",
-                "friends": ["2", "3"],  # Alice is friends with Bob and Charlie
-            },
-            "2": {
-                "id": "2",
-                "name": "Bob",
-                "friends": ["1"],  # Bob is friends with Alice
-            },
-            "3": {
-                "id": "3",
-                "name": "Charlie",
-                "friends": ["1", "2"],  # Charlie is friends with Alice and Bob
-            },
-        },
-    }
-
-    update = {"top_level": "updated", "nested": {"value": 100, "name": "updated"}}
-
-    expected = State(**inputs)
-
-    def node_fn(state: State) -> dict:
-        assert state == expected
-        return update
-
-    builder = StateGraph(State)
-    builder.add_node("process", node_fn)
-    builder.set_entry_point("process")
-    builder.set_finish_point("process")
-    graph = builder.compile()
-
-    result = graph.invoke(inputs.copy())
-
-    assert result == {**inputs, **update}
-
-    new_inputs = inputs.copy()
-    new_inputs["list_nested"] = {"foo": "bar"}
-    expected = State(**new_inputs)
-    assert {**new_inputs, **update} == graph.invoke(new_inputs.copy())
-
-
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
 def test_in_one_fan_out_state_graph_waiting_edge_plus_regular(
     request: pytest.FixtureRequest, checkpointer_name: str
@@ -5677,6 +5550,37 @@ def test_command_goto_with_static_breakpoints(
     assert result == {"foo": "abc|node-1|node-2|node-2"}
 
 
+def test_nested_graph_state_error_handling():
+    """Test error handling when updating state in nested graphs."""
+
+    class State(TypedDict):
+        count: int
+
+    def child_node(state: State):
+        return {"count": state["count"] + 1}
+
+    child = StateGraph(State)
+    child.add_node("child", child_node)
+    child.add_edge(START, "child")
+
+    parent = StateGraph(State)
+    parent.add_node("child_graph", child.compile())
+    parent.add_edge(START, "child_graph")
+
+    app = parent.compile(checkpointer=MemorySaver())
+
+    # Test invalid state update on parent
+    with pytest.raises(InvalidUpdateError):
+        app.update_state({"configurable": {"thread_id": "1"}}, {"invalid_key": "value"})
+
+    # Test invalid state update on child
+    with pytest.raises(InvalidUpdateError):
+        app.update_state(
+            {"configurable": {"thread_id": "1", "checkpoint_ns": "child_graph"}},
+            {"invalid_key": "value"},
+        )
+
+
 def test_parallel_node_execution():
     """Test that parallel nodes execute concurrently."""
 
@@ -5917,267 +5821,8 @@ def test_falsy_return_from_task(
         interrupt("test")
 
     configurable = {"configurable": {"thread_id": str(uuid.uuid4())}}
-    assert [
-        chunk for chunk in graph.stream({"a": 5}, configurable, stream_mode="debug")
-    ] == [
-        {
-            "payload": {
-                "config": {
-                    "callbacks": None,
-                    "configurable": {
-                        "checkpoint_id": AnyStr(),
-                        "checkpoint_ns": "",
-                        "thread_id": AnyStr(),
-                    },
-                    "metadata": configurable["configurable"],
-                    "recursion_limit": 25,
-                    "tags": [],
-                },
-                "metadata": {
-                    "parents": {},
-                    "source": "input",
-                    "step": -1,
-                    "thread_id": AnyStr(),
-                    "writes": {
-                        "__start__": {
-                            "a": 5,
-                        },
-                    },
-                },
-                "next": [
-                    "graph",
-                ],
-                "parent_config": None,
-                "tasks": [
-                    {
-                        "id": AnyStr(),
-                        "interrupts": (),
-                        "name": "graph",
-                        "state": None,
-                    },
-                ],
-                "values": None,
-            },
-            "step": -1,
-            "timestamp": AnyStr(),
-            "type": "checkpoint",
-        },
-        {
-            "payload": {
-                "id": AnyStr(),
-                "input": {
-                    "a": 5,
-                },
-                "name": "graph",
-                "triggers": [
-                    "__start__",
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task",
-        },
-        {
-            "payload": {
-                "id": AnyStr(),
-                "input": (
-                    (),
-                    {},
-                ),
-                "name": "falsy_task",
-                "triggers": [
-                    "__pregel_push",
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task",
-        },
-        {
-            "payload": {
-                "error": None,
-                "id": AnyStr(),
-                "interrupts": [],
-                "name": "falsy_task",
-                "result": [
-                    (
-                        "__return__",
-                        False,
-                    ),
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task_result",
-        },
-        {
-            "payload": {
-                "error": None,
-                "id": AnyStr(),
-                "interrupts": [
-                    {
-                        "ns": [
-                            AnyStr(),
-                        ],
-                        "resumable": True,
-                        "value": "test",
-                        "when": "during",
-                    },
-                ],
-                "name": "graph",
-                "result": [],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task_result",
-        },
-    ]
-    assert [
-        c
-        for c in graph.stream(Command(resume="123"), configurable, stream_mode="debug")
-    ] == [
-        {
-            "payload": {
-                "config": {
-                    "callbacks": None,
-                    "configurable": {
-                        "checkpoint_id": AnyStr(),
-                        "checkpoint_ns": "",
-                        "thread_id": AnyStr(),
-                    },
-                    "metadata": configurable["configurable"],
-                    "recursion_limit": 25,
-                    "tags": [],
-                },
-                "metadata": {
-                    "parents": {},
-                    "source": "input",
-                    "step": -1,
-                    "thread_id": AnyStr(),
-                    "writes": {
-                        "__start__": {
-                            "a": 5,
-                        },
-                    },
-                },
-                "next": [
-                    "graph",
-                ],
-                "parent_config": None,
-                "tasks": [
-                    {
-                        "id": AnyStr(),
-                        "interrupts": (
-                            {
-                                "ns": [
-                                    AnyStr(),
-                                ],
-                                "resumable": True,
-                                "value": "test",
-                                "when": "during",
-                            },
-                        ),
-                        "name": "graph",
-                        "state": None,
-                    },
-                ],
-                "values": None,
-            },
-            "step": -1,
-            "timestamp": AnyStr(),
-            "type": "checkpoint",
-        },
-        {
-            "payload": {
-                "id": AnyStr(),
-                "input": {
-                    "a": 5,
-                },
-                "name": "graph",
-                "triggers": [
-                    "__start__",
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task",
-        },
-        {
-            "payload": {
-                "id": AnyStr(),
-                "input": (
-                    (),
-                    {},
-                ),
-                "name": "falsy_task",
-                "triggers": [
-                    "__pregel_push",
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task",
-        },
-        {
-            "payload": {
-                "error": None,
-                "id": AnyStr(),
-                "interrupts": [],
-                "name": "graph",
-                "result": [
-                    (
-                        "__end__",
-                        None,
-                    ),
-                ],
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "task_result",
-        },
-        {
-            "payload": {
-                "config": {
-                    "callbacks": None,
-                    "configurable": {
-                        "checkpoint_id": AnyStr(),
-                        "checkpoint_ns": "",
-                        "thread_id": AnyStr(),
-                    },
-                    "metadata": configurable["configurable"],
-                    "recursion_limit": 25,
-                    "tags": [],
-                },
-                "metadata": {
-                    "parents": {},
-                    "source": "loop",
-                    "step": 0,
-                    "thread_id": AnyStr(),
-                    "writes": {
-                        "falsy_task": False,
-                        "graph": None,
-                    },
-                },
-                "next": [],
-                "parent_config": {
-                    "callbacks": None,
-                    "configurable": {
-                        "checkpoint_id": AnyStr(),
-                        "checkpoint_ns": "",
-                        "thread_id": AnyStr(),
-                    },
-                    "metadata": configurable["configurable"],
-                    "recursion_limit": 25,
-                    "tags": [],
-                },
-                "tasks": [],
-                "values": None,
-            },
-            "step": 0,
-            "timestamp": AnyStr(),
-            "type": "checkpoint",
-        },
-    ]
+    graph.invoke({"a": 5}, configurable)
+    graph.invoke(Command(resume="123"), configurable)
 
 
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
@@ -7013,40 +6658,6 @@ def test_pydantic_none_state_update() -> None:
     assert graph.invoke({"foo": ""}) == {"foo": None}
 
 
-def test_pydantic_state_mutation() -> None:
-    from pydantic import BaseModel, Field
-
-    class Inner(BaseModel):
-        a: int = 0
-
-    class State(BaseModel):
-        inner: Inner = Inner()
-        outer: int = 0
-
-    def my_node(state: State) -> State:
-        state.inner.a = 5
-        state.outer = 10
-        return state
-
-    graph = StateGraph(State).add_node(my_node).add_edge(START, "my_node").compile()
-
-    assert graph.invoke({"outer": 1}) == {"outer": 10, "inner": Inner(a=5)}
-
-    # test w/ default_factory
-    class State(BaseModel):
-        inner: Inner = Field(default_factory=Inner)
-        outer: int = 0
-
-    def my_node(state: State) -> State:
-        state.inner.a = 5
-        state.outer = 10
-        return state
-
-    graph = StateGraph(State).add_node(my_node).add_edge(START, "my_node").compile()
-
-    assert graph.invoke({"outer": 1}) == {"outer": 10, "inner": Inner(a=5)}
-
-
 def test_get_stream_writer() -> None:
     class State(TypedDict):
         foo: str
@@ -7267,347 +6878,3 @@ def test_interrupt_subgraph_reenter_checkpointer_true(
     }
     # confirm that we preserve the state values from the previous invocation
     assert bar_values == [None, "barbaz", "quxbaz"]
-
-
-def test_empty_invoke() -> None:
-    from pydantic import BaseModel
-
-    def reducer_merge_dicts(
-        dict1: dict[Any, Any], dict2: dict[Any, Any]
-    ) -> dict[Any, Any]:
-        merged = {**dict1, **dict2}
-        return merged
-
-    class SimpleGraphState(BaseModel):
-        x1: Annotated[list[str], operator.add] = []
-        x2: Annotated[dict[str, Any], reducer_merge_dicts] = {}
-
-    def update_x1_1(state: SimpleGraphState):
-        print(state)
-        return {"x1": ["111"]}
-
-    def update_x1_2(state: SimpleGraphState):
-        print(state)
-        state.x1.append("222")
-        return {"x1": ["222"]}
-
-    def update_x2_1(state: SimpleGraphState):
-        print(state)
-        return {"x2": {"111": 111}}
-
-    def update_x2_2(state: SimpleGraphState):
-        print(state)
-        return {"x2": {"222": 222}}
-
-    graph = StateGraph(SimpleGraphState)
-    graph.add_node("x1_1_node", update_x1_1)
-    graph.add_node("x1_2_node", update_x1_2)
-    graph.add_node("x2_1_node", update_x2_1)
-    graph.add_node("x2_2_node", update_x2_2)
-    graph.add_edge("x1_1_node", "x1_2_node")
-    graph.add_edge("x1_2_node", "x2_1_node")
-    graph.add_edge("x2_1_node", "x2_2_node")
-
-    graph.add_edge(START, "x1_1_node")
-    graph.add_edge("x2_2_node", END)
-
-    compiled = graph.compile()
-
-    assert compiled.invoke(SimpleGraphState()).get("x2") == {
-        "111": 111,
-        "222": 222,
-    }
-
-
-@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
-def test_parallel_interrupts(
-    request: pytest.FixtureRequest, checkpointer_name: str
-) -> None:
-    from pydantic import BaseModel, Field
-
-    checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
-
-    # --- CHILD GRAPH ---
-
-    class ChildState(BaseModel):
-        prompt: str = Field(..., description="What is going to be asked to the user?")
-        human_input: Optional[str] = Field(None, description="What the human said")
-        human_inputs: Annotated[List[str], operator.add] = Field(
-            default_factory=list, description="All of my messages"
-        )
-
-    def get_human_input(state: ChildState):
-        human_input = interrupt(state.prompt)
-
-        return dict(
-            human_input=human_input,  # update child state
-            human_inputs=[human_input],  # update parent state
-        )
-
-    child_graph_builder = StateGraph(ChildState)
-    child_graph_builder.add_node("get_human_input", get_human_input)
-    child_graph_builder.add_edge(START, "get_human_input")
-    child_graph_builder.add_edge("get_human_input", END)
-    child_graph = child_graph_builder.compile()
-
-    # --- PARENT GRAPH ---
-
-    class ParentState(BaseModel):
-        prompts: List[str] = Field(
-            ..., description="What is going to be asked to the user?"
-        )
-        human_inputs: Annotated[List[str], operator.add] = Field(
-            default_factory=list, description="All of my messages"
-        )
-
-    def assign_workers(state: ParentState):
-        return [
-            Send(
-                "child_graph",
-                dict(
-                    prompt=prompt,
-                ),
-            )
-            for prompt in state.prompts
-        ]
-
-    def cleanup(state: ParentState):
-        assert len(state.human_inputs) == len(state.prompts)
-
-    parent_graph_builder = StateGraph(ParentState)
-    parent_graph_builder.add_node("child_graph", child_graph)
-    parent_graph_builder.add_node("cleanup", cleanup)
-
-    parent_graph_builder.add_conditional_edges(START, assign_workers, ["child_graph"])
-    parent_graph_builder.add_edge("child_graph", "cleanup")
-    parent_graph_builder.add_edge("cleanup", END)
-
-    parent_graph = parent_graph_builder.compile(checkpointer=checkpointer)
-
-    # --- CLIENT INVOCATION ---
-
-    thread_config = dict(
-        configurable=dict(
-            thread_id=str(uuid.uuid4()),
-        )
-    )
-    current_input = dict(
-        prompts=["a", "b"],
-    )
-
-    invokes = 0
-    events: dict[int, list[dict]] = {}
-    while invokes < 10:
-        # reset interrupt
-        invokes += 1
-        events[invokes] = []
-        current_interrupts: list[Interrupt] = []
-
-        # start / resume the graph
-        for event in parent_graph.stream(
-            input=current_input,
-            config=thread_config,
-            stream_mode="updates",
-        ):
-            events[invokes].append(event)
-            # handle the interrupt
-            if "__interrupt__" in event:
-                current_interrupts.extend(event["__interrupt__"])
-                # assume that it breaks here, because it is an interrupt
-
-        # get human input and resume
-        if any(i.resumable for i in current_interrupts):
-            current_input = Command(resume=f"Resume #{invokes}")
-
-        # not more human input required, must be completed
-        else:
-            break
-    else:
-        assert False, "Detected infinite loop"
-
-    assert invokes == 3
-    assert len(events) == 3
-
-    assert events[1] == UnsortedSequence(
-        {
-            "__interrupt__": (
-                Interrupt(
-                    value="a",
-                    resumable=True,
-                    ns=[
-                        AnyStr("child_graph:"),
-                        AnyStr("get_human_input:"),
-                    ],
-                ),
-            )
-        },
-        {
-            "__interrupt__": (
-                Interrupt(
-                    value="b",
-                    resumable=True,
-                    ns=[
-                        AnyStr("child_graph:"),
-                        AnyStr("get_human_input:"),
-                    ],
-                ),
-            )
-        },
-    )
-    assert events[2] in (
-        UnsortedSequence(
-            {
-                "__interrupt__": (
-                    Interrupt(
-                        value="a",
-                        resumable=True,
-                        ns=[
-                            AnyStr("child_graph:"),
-                            AnyStr("get_human_input:"),
-                        ],
-                    ),
-                )
-            },
-            {"child_graph": {"human_inputs": ["Resume #1"]}},
-        ),
-        UnsortedSequence(
-            {
-                "__interrupt__": (
-                    Interrupt(
-                        value="b",
-                        resumable=True,
-                        ns=[
-                            AnyStr("child_graph:"),
-                            AnyStr("get_human_input:"),
-                        ],
-                    ),
-                )
-            },
-            {"child_graph": {"human_inputs": ["Resume #1"]}},
-        ),
-    )
-    assert events[3] == UnsortedSequence(
-        {
-            "child_graph": {"human_inputs": ["Resume #1"]},
-            "__metadata__": {"cached": True},
-        },
-        {"child_graph": {"human_inputs": ["Resume #2"]}},
-        {"cleanup": None},
-    )
-
-
-@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
-def test_parallel_interrupts_double(
-    request: pytest.FixtureRequest, checkpointer_name: str
-) -> None:
-    from pydantic import BaseModel, Field
-
-    checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
-
-    # --- CHILD GRAPH ---
-
-    class ChildState(BaseModel):
-        prompt: str = Field(..., description="What is going to be asked to the user?")
-        human_input: Optional[str] = Field(None, description="What the human said")
-        human_inputs: Annotated[List[str], operator.add] = Field(
-            default_factory=list, description="All of my messages"
-        )
-
-    def get_human_input(state: ChildState):
-        human_input = interrupt(state.prompt)
-
-        return dict(
-            human_inputs=[human_input],  # update parent state
-        )
-
-    def get_dolphin_input(state: ChildState):
-        human_input = interrupt(state.prompt)
-
-        return dict(
-            human_inputs=[human_input],  # update parent state
-        )
-
-    child_graph_builder = StateGraph(ChildState)
-    child_graph_builder.add_node("get_human_input", get_human_input)
-    child_graph_builder.add_node("get_dolphin_input", get_dolphin_input)
-    child_graph_builder.add_edge(START, "get_human_input")
-    child_graph_builder.add_edge(START, "get_dolphin_input")
-    child_graph = child_graph_builder.compile()
-
-    # --- PARENT GRAPH ---
-
-    class ParentState(BaseModel):
-        prompts: List[str] = Field(
-            ..., description="What is going to be asked to the user?"
-        )
-        human_inputs: Annotated[List[str], operator.add] = Field(
-            default_factory=list, description="All of my messages"
-        )
-
-    def assign_workers(state: ParentState):
-        return [
-            Send(
-                "child_graph",
-                dict(
-                    prompt=prompt,
-                ),
-            )
-            for prompt in state.prompts
-        ]
-
-    def cleanup(state: ParentState):
-        assert len(state.human_inputs) == len(state.prompts) * 2
-
-    parent_graph_builder = StateGraph(ParentState)
-    parent_graph_builder.add_node("child_graph", child_graph)
-    parent_graph_builder.add_node("cleanup", cleanup)
-
-    parent_graph_builder.add_conditional_edges(START, assign_workers, ["child_graph"])
-    parent_graph_builder.add_edge("child_graph", "cleanup")
-    parent_graph_builder.add_edge("cleanup", END)
-
-    parent_graph = parent_graph_builder.compile(checkpointer=checkpointer)
-
-    # --- CLIENT INVOCATION ---
-
-    thread_config = dict(
-        configurable=dict(
-            thread_id=str(uuid.uuid4()),
-        )
-    )
-    current_input = dict(
-        prompts=["a", "b"],
-    )
-
-    invokes = 0
-    events: dict[int, list[dict]] = {}
-    while invokes < 10:
-        # reset interrupt
-        invokes += 1
-        events[invokes] = []
-        current_interrupts: list[Interrupt] = []
-
-        # start / resume the graph
-        for event in parent_graph.stream(
-            input=current_input,
-            config=thread_config,
-            stream_mode="updates",
-        ):
-            events[invokes].append(event)
-            # handle the interrupt
-            if "__interrupt__" in event:
-                current_interrupts.extend(event["__interrupt__"])
-                # assume that it breaks here, because it is an interrupt
-
-        # get human input and resume
-        if any(i.resumable for i in current_interrupts):
-            current_input = Command(resume=f"Resume #{invokes}")
-
-        # not more human input required, must be completed
-        else:
-            break
-    else:
-        assert False, "Detected infinite loop"
-
-    assert invokes == 5
-    assert len(events) == 5

libs/langgraph/tests/test_pregel_async.py

@@ -938,7 +938,10 @@ async def test_copy_checkpoint(checkpointer_name: str) -> None:
             async for c in tool_two.astream(
                 {"my_key": "value ⛰️", "market": "DE"}, thread2
             )
-        ] == UnsortedSequence(
+        ] == [
+            {
+                "tool_one": {"my_key": " one"},
+            },
             {
                 "__interrupt__": (
                     Interrupt(
@@ -948,10 +951,7 @@ async def test_copy_checkpoint(checkpointer_name: str) -> None:
                     ),
                 )
             },
-            {
-                "tool_one": {"my_key": " one"},
-            },
-        )
+        ]
         # resume with answer
         assert [
             c async for c in tool_two.astream(Command(resume=" my answer"), thread2)
@@ -4511,116 +4511,6 @@ async def test_in_one_fan_out_state_graph_waiting_edge_via_branch(
         ]
 
 
-@pytest.mark.parametrize("version", ["v1", "v2"])
-async def test_nested_pydantic_models(version: str) -> None:
-    """Test that nested Pydantic models are properly constructed from leaf nodes up."""
-
-    # Define nested Pydantic models
-    if version == "v1":
-        from pydantic.v1 import BaseModel, Field
-    else:
-        from pydantic import BaseModel, Field
-
-    class NestedModel(BaseModel):
-        value: int
-        name: str
-
-    # Forward reference model
-    class RecursiveModel(BaseModel):
-        value: str
-        child: Optional["RecursiveModel"] = None
-
-    # Discriminated union models
-    class Cat(BaseModel):
-        pet_type: Literal["cat"]
-        meow: str
-
-    class Dog(BaseModel):
-        pet_type: Literal["dog"]
-        bark: str
-
-    # Cyclic reference model
-    class Person(BaseModel):
-        id: str
-        name: str
-        friends: list[str] = Field(default_factory=list)  # IDs of friends
-
-    class State(BaseModel):
-        # Basic nested model tests
-        top_level: str
-        nested: NestedModel
-        optional_nested: Optional[NestedModel] = None
-        dict_nested: dict[str, NestedModel]
-        list_nested: Annotated[
-            Union[dict, list[dict[str, NestedModel]]], lambda x, y: (x or []) + [y]
-        ]
-        tuple_nested: tuple[str, NestedModel]
-        tuple_list_nested: list[tuple[int, NestedModel]]
-        complex_tuple: tuple[str, dict[str, tuple[int, NestedModel]]]
-
-        # Forward reference test
-        recursive: RecursiveModel
-
-        # Discriminated union test
-        pet: Union[Cat, Dog]
-
-        # Cyclic reference test
-        people: dict[str, Person]  # Map of ID -> Person
-
-    inputs = {
-        # Basic nested models
-        "top_level": "initial",
-        "nested": {"value": 42, "name": "test"},
-        "optional_nested": {"value": 10, "name": "optional"},
-        "dict_nested": {"a": {"value": 5, "name": "a"}},
-        "list_nested": [{"a": {"value": 6, "name": "b"}}],
-        "tuple_nested": ["tuple-key", {"value": 7, "name": "tuple-value"}],
-        "tuple_list_nested": [[1, {"value": 8, "name": "tuple-in-list"}]],
-        "complex_tuple": [
-            "complex",
-            {"nested": [9, {"value": 10, "name": "deep"}]},
-        ],
-        # Forward reference
-        "recursive": {"value": "parent", "child": {"value": "child", "child": None}},
-        # Discriminated union (using a cat in this case)
-        "pet": {"pet_type": "cat", "meow": "meow!"},
-        # Cyclic references
-        "people": {
-            "1": {
-                "id": "1",
-                "name": "Alice",
-                "friends": ["2", "3"],  # Alice is friends with Bob and Charlie
-            },
-            "2": {
-                "id": "2",
-                "name": "Bob",
-                "friends": ["1"],  # Bob is friends with Alice
-            },
-            "3": {
-                "id": "3",
-                "name": "Charlie",
-                "friends": ["1", "2"],  # Charlie is friends with Alice and Bob
-            },
-        },
-    }
-
-    update = {"top_level": "updated", "nested": {"value": 100, "name": "updated"}}
-
-    async def node_fn(state: State) -> dict:
-        assert state == State(**inputs)
-        return update
-
-    builder = StateGraph(State)
-    builder.add_node("process", node_fn)
-    builder.set_entry_point("process")
-    builder.set_finish_point("process")
-    graph = builder.compile()
-
-    result = await graph.ainvoke(inputs.copy())
-
-    assert result == {**inputs, **update}
-
-
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
 async def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class(
     snapshot: SnapshotAssertion, mocker: MockerFixture, checkpointer_name: str
@@ -6654,6 +6544,39 @@ async def test_command_goto_with_static_breakpoints(checkpointer_name: str) -> N
         assert result == {"foo": "abc|node-1|node-2|node-2"}
 
 
+async def test_nested_graph_state_error_handling():
+    """Test error handling when updating state in nested graphs."""
+
+    class State(TypedDict):
+        count: int
+
+    def child_node(state: State):
+        return {"count": state["count"] + 1}
+
+    child = StateGraph(State)
+    child.add_node("child", child_node)
+    child.add_edge(START, "child")
+
+    parent = StateGraph(State)
+    parent.add_node("child_graph", child.compile())
+    parent.add_edge(START, "child_graph")
+
+    app = parent.compile(checkpointer=MemorySaver())
+
+    # Test invalid state update on parent
+    with pytest.raises(InvalidUpdateError):
+        await app.aupdate_state(
+            {"configurable": {"thread_id": "1"}}, {"invalid_key": "value"}
+        )
+
+    # Test invalid state update on child
+    with pytest.raises(InvalidUpdateError):
+        await app.aupdate_state(
+            {"configurable": {"thread_id": "1", "checkpoint_ns": "child_graph"}},
+            {"invalid_key": "value"},
+        )
+
+
 async def test_parallel_node_execution():
     """Test that parallel nodes execute concurrently."""
 
@@ -7774,56 +7697,3 @@ async def test_interrupt_subgraph_reenter_checkpointer_true(
         }
         # confirm that we preserve the state values from the previous invocation
         assert bar_values == [None, "barbaz", "quxbaz"]
-
-
-@NEEDS_CONTEXTVARS
-async def test_handles_multiple_interrupts_from_tasks() -> None:
-    @task
-    async def add_participant(name: str) -> str:
-        feedback = interrupt(f"Hey do you want to add {name}?")
-
-        if feedback is False:
-            return f"The user changed their mind and doesn't want to add {name}!"
-
-        if feedback is True:
-            return f"Added {name}!"
-
-        raise ValueError("Invalid feedback")
-
-    @entrypoint(checkpointer=MemorySaver())
-    async def program(_state: Any) -> list[str]:
-        first = await add_participant("James")
-        second = await add_participant("Will")
-        return [first, second]
-
-    config = {"configurable": {"thread_id": "1"}}
-
-    result = await program.ainvoke("this is ignored", config=config)
-    assert result is None
-
-    state = await program.aget_state(config=config)
-    assert len(state.tasks[0].interrupts) == 1
-    task_interrupt = state.tasks[0].interrupts[0]
-    assert task_interrupt.resumable is True
-    assert len(task_interrupt.ns) == 2
-    assert task_interrupt.ns[0].startswith("program:")
-    assert task_interrupt.ns[1].startswith("add_participant:")
-    assert task_interrupt.value == "Hey do you want to add James?"
-
-    result = await program.ainvoke(Command(resume=True), config=config)
-    assert result is None
-
-    state = await program.aget_state(config=config)
-    assert len(state.tasks[0].interrupts) == 1
-    task_interrupt = state.tasks[0].interrupts[0]
-    assert task_interrupt.resumable is True
-    assert len(task_interrupt.ns) == 2
-    assert task_interrupt.ns[0].startswith("program:")
-    assert task_interrupt.ns[1].startswith("add_participant:")
-    assert task_interrupt.value == "Hey do you want to add Will?"
-
-    result = await program.ainvoke(Command(resume=True), config=config)
-    assert result is not None
-    assert len(result) == 2
-    assert result[0] == "Added James!"
-    assert result[1] == "Added Will!"

libs/langgraph/tests/test_state.py

@@ -1,5 +1,4 @@
 import inspect
-import operator
 import warnings
 from dataclasses import dataclass, field
 from typing import Annotated as Annotated2
@@ -329,74 +328,3 @@ def test__get_node_name() -> None:
 
     # class method
     assert _get_node_name(MyClass().class_method) == "class_method"
-
-
-def test_input_schema_conditional_edge():
-    class OverallState(TypedDict):
-        foo: Annotated[int, operator.add]
-        bar: str
-
-    class PrivateState(TypedDict):
-        baz: str
-
-    builder = StateGraph(OverallState)
-
-    def node_1(state: OverallState):
-        return {"foo": 1, "baz": "bar"}
-
-    def node_2(state: PrivateState):
-        return {"foo": 1, "bar": state["baz"], "something_else": "meow"}
-
-    def node_3(state: OverallState):
-        return {"foo": 1}
-
-    def router(state: OverallState):
-        assert state == {"foo": 2, "bar": "bar"}
-        if state["foo"] == 2:
-            return "node_3"
-        else:
-            return "__end__"
-
-    builder.add_node(node_1)
-    builder.add_node(node_2)
-    builder.add_node(node_3)
-    builder.add_conditional_edges("node_2", router)
-    builder.add_edge("__start__", "node_1")
-    builder.add_edge("node_1", "node_2")
-    graph = builder.compile()
-    assert graph.invoke({"foo": 0}) == {"foo": 3, "bar": "bar"}
-
-
-def test_private_input_schema_conditional_edge():
-    class OverallState(TypedDict):
-        foo: Annotated[int, operator.add]
-        bar: str
-
-    class RouterState(TypedDict):
-        baz: str
-
-    class Node2State(TypedDict):
-        foo: Annotated[int, operator.add]
-        baz: str
-
-    builder = StateGraph(OverallState)
-
-    def node_1(state: OverallState):
-        return {"foo": 1, "baz": "meow"}
-
-    def node_2(state: Node2State):
-        return {"foo": 1, "bar": state["baz"]}
-
-    def router(state: RouterState):
-        assert state == {"baz": "meow"}
-        if state["baz"] == "meow":
-            return "node_2"
-        else:
-            return "__end__"
-
-    builder.add_node(node_1)
-    builder.add_node(node_2)
-    builder.add_conditional_edges("node_1", router)
-    builder.add_edge("__start__", "node_1")
-    graph = builder.compile()
-    assert graph.invoke({"foo": 0}) == {"foo": 2, "bar": "meow"}

libs/prebuilt/langgraph/prebuilt/chat_agent_executor.py

@@ -10,7 +10,6 @@ from typing import (
     TypeVar,
     Union,
     cast,
-    get_type_hints,
 )
 
 from langchain_core.language_models import (
@@ -58,27 +57,13 @@ class AgentState(TypedDict):
     remaining_steps: RemainingSteps
 
 
-class AgentStatePydantic(BaseModel):
-    """The state of the agent."""
-
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-
-    remaining_steps: RemainingSteps = 25
-
-
 class AgentStateWithStructuredResponse(AgentState):
     """The state of the agent with a structured response."""
 
     structured_response: StructuredResponse
 
 
-class AgentStateWithStructuredResponsePydantic(AgentStatePydantic):
-    """The state of the agent with a structured response."""
-
-    structured_response: StructuredResponse
-
-
-StateSchema = TypeVar("StateSchema", bound=Union[AgentState, AgentStatePydantic])
+StateSchema = TypeVar("StateSchema", bound=AgentState)
 StateSchemaType = Type[StateSchema]
 
 PROMPT_RUNNABLE_NAME = "Prompt"
@@ -91,29 +76,21 @@ Prompt = Union[
 ]
 
 
-def _get_state_value(state: StateSchema, key: str, default: Any = None) -> Any:
-    return (
-        state.get(key, default)
-        if isinstance(state, dict)
-        else getattr(state, key, default)
-    )
-
-
 def _get_prompt_runnable(prompt: Optional[Prompt]) -> Runnable:
     prompt_runnable: Runnable
     if prompt is None:
         prompt_runnable = RunnableCallable(
-            lambda state: _get_state_value(state, "messages"), name=PROMPT_RUNNABLE_NAME
+            lambda state: state["messages"], name=PROMPT_RUNNABLE_NAME
         )
     elif isinstance(prompt, str):
         _system_message: BaseMessage = SystemMessage(content=prompt)
         prompt_runnable = RunnableCallable(
-            lambda state: [_system_message] + _get_state_value(state, "messages"),
+            lambda state: [_system_message] + state["messages"],
             name=PROMPT_RUNNABLE_NAME,
         )
     elif isinstance(prompt, SystemMessage):
         prompt_runnable = RunnableCallable(
-            lambda state: [prompt] + _get_state_value(state, "messages"),
+            lambda state: [prompt] + state["messages"],
             name=PROMPT_RUNNABLE_NAME,
         )
     elif inspect.iscoroutinefunction(prompt):
@@ -257,7 +234,7 @@ def _validate_chat_history(
 @_convert_modifier_to_prompt
 def create_react_agent(
     model: Union[str, LanguageModelLike],
-    tools: Union[Sequence[Union[BaseTool, Callable]], ToolNode],
+    tools: Union[Sequence[BaseTool], ToolNode],
     *,
     prompt: Optional[Prompt] = None,
     response_format: Optional[
@@ -306,7 +283,7 @@ def create_react_agent(
                 The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.
                 This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).
         state_schema: An optional state schema that defines graph state.
-            Must have `messages` and `remaining_steps` keys.
+            Must have `messages` and `is_last_step` keys.
             Defaults to `AgentState` that defines those two keys.
         config_schema: An optional schema for configuration.
             Use this to expose configurable parameters via agent.config_specs.
@@ -382,11 +359,12 @@ def create_react_agent(
         Use with a simple tool:
 
         ```pycon
+        >>> from datetime import datetime
         >>> from langchain_openai import ChatOpenAI
         >>> from langgraph.prebuilt import create_react_agent
 
 
-        ... def check_weather(location: str) -> str:
+        ... def check_weather(location: str, at_time: datetime | None = None) -> str:
         ...     '''Return the weather forecast for the specified location.'''
         ...     return f"It's always sunny in {location}"
         >>>
@@ -594,7 +572,7 @@ def create_react_agent(
 
         ```pycon
         >>> import time
-        ... def check_weather(location: str) -> str:
+        ... def check_weather(location: str, at_time: datetime | None = None) -> float:
         ...     '''Return the weather forecast for the specified location.'''
         ...     time.sleep(2)
         ...     return f"It's always sunny in {location}"
@@ -617,8 +595,7 @@ def create_react_agent(
         if response_format is not None:
             required_keys.add("structured_response")
 
-        schema_keys = set(get_type_hints(state_schema))
-        if missing_keys := required_keys - set(schema_keys):
+        if missing_keys := required_keys - set(state_schema.__annotations__):
             raise ValueError(f"Missing required key(s) {missing_keys} in state_schema")
 
     if state_schema is None:
@@ -659,34 +636,35 @@ def create_react_agent(
     # our graph needs to check if these were called
     should_return_direct = {t.name for t in tool_classes if t.return_direct}
 
-    def _are_more_steps_needed(state: StateSchema, response: BaseMessage) -> bool:
+    # Define the function that calls the model
+    def call_model(state: AgentState, config: RunnableConfig) -> AgentState:
+        _validate_chat_history(state["messages"])
+        response = cast(AIMessage, model_runnable.invoke(state, config))
+        # add agent name to the AIMessage
+        response.name = name
         has_tool_calls = isinstance(response, AIMessage) and response.tool_calls
         all_tools_return_direct = (
             all(call["name"] in should_return_direct for call in response.tool_calls)
             if isinstance(response, AIMessage)
             else False
         )
-        remaining_steps = _get_state_value(state, "remaining_steps", None)
-        is_last_step = _get_state_value(state, "is_last_step", False)
-        return (
-            (remaining_steps is None and is_last_step and has_tool_calls)
+        if (
+            (
+                "remaining_steps" not in state
+                and state.get("is_last_step", False)
+                and has_tool_calls
+            )
             or (
-                remaining_steps is not None
-                and remaining_steps < 1
+                "remaining_steps" in state
+                and state["remaining_steps"] < 1
                 and all_tools_return_direct
             )
-            or (remaining_steps is not None and remaining_steps < 2 and has_tool_calls)
-        )
-
-    # Define the function that calls the model
-    def call_model(state: StateSchema, config: RunnableConfig) -> StateSchema:
-        messages = _get_state_value(state, "messages")
-        _validate_chat_history(messages)
-        response = cast(AIMessage, model_runnable.invoke(state, config))
-        # add agent name to the AIMessage
-        response.name = name
-
-        if _are_more_steps_needed(state, response):
+            or (
+                "remaining_steps" in state
+                and state["remaining_steps"] < 2
+                and has_tool_calls
+            )
+        ):
             return {
                 "messages": [
                     AIMessage(
@@ -698,13 +676,34 @@ def create_react_agent(
         # We return a list, because this will get added to the existing list
         return {"messages": [response]}
 
-    async def acall_model(state: StateSchema, config: RunnableConfig) -> StateSchema:
-        messages = _get_state_value(state, "messages")
-        _validate_chat_history(messages)
+    async def acall_model(state: AgentState, config: RunnableConfig) -> AgentState:
+        _validate_chat_history(state["messages"])
         response = cast(AIMessage, await model_runnable.ainvoke(state, config))
         # add agent name to the AIMessage
         response.name = name
-        if _are_more_steps_needed(state, response):
+        has_tool_calls = isinstance(response, AIMessage) and response.tool_calls
+        all_tools_return_direct = (
+            all(call["name"] in should_return_direct for call in response.tool_calls)
+            if isinstance(response, AIMessage)
+            else False
+        )
+        if (
+            (
+                "remaining_steps" not in state
+                and state.get("is_last_step", False)
+                and has_tool_calls
+            )
+            or (
+                "remaining_steps" in state
+                and state["remaining_steps"] < 1
+                and all_tools_return_direct
+            )
+            or (
+                "remaining_steps" in state
+                and state["remaining_steps"] < 2
+                and has_tool_calls
+            )
+        ):
             return {
                 "messages": [
                     AIMessage(
@@ -717,11 +716,11 @@ def create_react_agent(
         return {"messages": [response]}
 
     def generate_structured_response(
-        state: StateSchema, config: RunnableConfig
-    ) -> StateSchema:
+        state: AgentState, config: RunnableConfig
+    ) -> AgentState:
         # NOTE: we exclude the last message because there is enough information
         # for the LLM to generate the structured response
-        messages = _get_state_value(state, "messages")[:-1]
+        messages = state["messages"][:-1]
         structured_response_schema = response_format
         if isinstance(response_format, tuple):
             system_prompt, structured_response_schema = response_format
@@ -734,11 +733,11 @@ def create_react_agent(
         return {"structured_response": response}
 
     async def agenerate_structured_response(
-        state: StateSchema, config: RunnableConfig
-    ) -> StateSchema:
+        state: AgentState, config: RunnableConfig
+    ) -> AgentState:
         # NOTE: we exclude the last message because there is enough information
         # for the LLM to generate the structured response
-        messages = _get_state_value(state, "messages")[:-1]
+        messages = state["messages"][:-1]
         structured_response_schema = response_format
         if isinstance(response_format, tuple):
             system_prompt, structured_response_schema = response_format
@@ -774,8 +773,8 @@ def create_react_agent(
         )
 
     # Define the function that determines whether to continue or not
-    def should_continue(state: StateSchema) -> Union[str, list]:
-        messages = _get_state_value(state, "messages")
+    def should_continue(state: AgentState) -> Union[str, list]:
+        messages = state["messages"]
         last_message = messages[-1]
         # If there is no function call, then we finish
         if not isinstance(last_message, AIMessage) or not last_message.tool_calls:
@@ -825,8 +824,8 @@ def create_react_agent(
         path_map=should_continue_destinations,
     )
 
-    def route_tool_responses(state: StateSchema) -> Literal["agent", "__end__"]:
-        for m in reversed(_get_state_value(state, "messages")):
+    def route_tool_responses(state: AgentState) -> Literal["agent", "__end__"]:
+        for m in reversed(state["messages"]):
             if not isinstance(m, ToolMessage):
                 break
             if m.name in should_return_direct:
@@ -858,7 +857,4 @@ __all__ = [
     "create_react_agent",
     "create_tool_calling_executor",
     "AgentState",
-    "AgentStatePydantic",
-    "AgentStateWithStructuredResponse",
-    "AgentStateWithStructuredResponsePydantic",
 ]

libs/prebuilt/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-prebuilt"
-version = "0.1.3"
+version = "0.1.2"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 license = "MIT"

libs/prebuilt/tests/test_react_agent.py

@@ -5,7 +5,6 @@ from functools import partial
 from typing import (
     Annotated,
     List,
-    Optional,
     Type,
     TypeVar,
     Union,
@@ -36,8 +35,6 @@ from langgraph.prebuilt import (
 )
 from langgraph.prebuilt.chat_agent_executor import (
     AgentState,
-    AgentStatePydantic,
-    StateSchemaType,
     _get_model,
     _should_bind_tools,
     _validate_chat_history,
@@ -531,31 +528,22 @@ def test_react_agent_with_structured_response(version: str) -> None:
         assert response["messages"][-2].content == "The weather is sunny and 75°F."
 
 
-class CustomState(AgentState):
-    user_name: str
-
-
-class CustomStatePydantic(AgentStatePydantic):
-    user_name: Optional[str] = None
-
-
 @pytest.mark.skipif(
     not IS_LANGCHAIN_CORE_030_OR_GREATER,
     reason="Langchain core 0.3.0 or greater is required",
 )
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-@pytest.mark.parametrize("state_schema", [CustomState, CustomStatePydantic])
 def test_react_agent_update_state(
-    request: pytest.FixtureRequest,
-    checkpointer_name: str,
-    version: str,
-    state_schema: StateSchemaType,
+    request: pytest.FixtureRequest, checkpointer_name: str, version: str
 ) -> None:
     checkpointer: BaseCheckpointSaver = request.getfixturevalue(
         "checkpointer_" + checkpointer_name
     )
 
+    class State(AgentState):
+        user_name: str
+
     @dec_tool
     def get_user_name(tool_call_id: Annotated[str, InjectedToolCallId]):
         """Retrieve user name"""
@@ -571,31 +559,20 @@ def test_react_agent_update_state(
             }
         )
 
-    if issubclass(state_schema, AgentStatePydantic):
+    def prompt(state: State):
+        user_name = state.get("user_name")
+        if user_name is None:
+            return state["messages"]
 
-        def prompt(state: CustomStatePydantic):
-            user_name = state.user_name
-            if user_name is None:
-                return state.messages
-
-            system_msg = f"User name is {user_name}"
-            return [{"role": "system", "content": system_msg}] + state.messages
-    else:
-
-        def prompt(state: CustomState):
-            user_name = state.get("user_name")
-            if user_name is None:
-                return state["messages"]
-
-            system_msg = f"User name is {user_name}"
-            return [{"role": "system", "content": system_msg}] + state["messages"]
+        system_msg = f"User name is {user_name}"
+        return [{"role": "system", "content": system_msg}] + state["messages"]
 
     tool_calls = [[{"args": {}, "id": "1", "name": "get_user_name"}]]
     model = FakeToolCallingModel(tool_calls=tool_calls)
     agent = create_react_agent(
         model,
         [get_user_name],
-        state_schema=state_schema,
+        state_schema=State,
         prompt=prompt,
         checkpointer=checkpointer,
         version=version,
@@ -825,45 +802,23 @@ def test_tool_node_inject_state(schema_: Type[T]) -> None:
     assert tool_message.content == "hi?"
 
 
-class AgentStateExtraKey(AgentState):
-    foo: int
-
-
-class AgentStateExtraKeyPydantic(AgentStatePydantic):
-    foo: int
-
-
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-@pytest.mark.parametrize(
-    "state_schema", [AgentStateExtraKey, AgentStateExtraKeyPydantic]
-)
-def test_create_react_agent_inject_vars(
-    version: str, state_schema: StateSchemaType
-) -> None:
+def test_create_react_agent_inject_vars(version: str) -> None:
+    class AgentStateExtraKey(AgentState):
+        foo: int
+
     store = InMemoryStore()
     namespace = ("test",)
     store.put(namespace, "test_key", {"bar": 3})
 
-    if issubclass(state_schema, AgentStatePydantic):
-
-        def tool1(
-            some_val: int,
-            state: Annotated[AgentStateExtraKeyPydantic, InjectedState],
-            store: Annotated[BaseStore, InjectedStore()],
-        ) -> str:
-            """Tool 1 docstring."""
-            store_val = store.get(namespace, "test_key").value["bar"]
-            return some_val + state.foo + store_val
-    else:
-
-        def tool1(
-            some_val: int,
-            state: Annotated[dict, InjectedState],
-            store: Annotated[BaseStore, InjectedStore()],
-        ) -> str:
-            """Tool 1 docstring."""
-            store_val = store.get(namespace, "test_key").value["bar"]
-            return some_val + state["foo"] + store_val
+    def tool1(
+        some_val: int,
+        state: Annotated[dict, InjectedState],
+        store: Annotated[BaseStore, InjectedStore()],
+    ) -> str:
+        """Tool 1 docstring."""
+        store_val = store.get(namespace, "test_key").value["bar"]
+        return some_val + state["foo"] + store_val
 
     tool_call = {
         "name": "tool1",
@@ -875,7 +830,7 @@ def test_create_react_agent_inject_vars(
     agent = create_react_agent(
         model,
         [tool1],
-        state_schema=state_schema,
+        state_schema=AgentStateExtraKey,
         store=store,
         version=version,
     )

libs/scheduler-kafka/tests/test_subgraph.py

@@ -202,7 +202,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": None,
@@ -275,7 +275,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -378,7 +378,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -491,7 +491,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": None,
@@ -559,7 +559,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -683,7 +683,7 @@ async def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],

libs/scheduler-kafka/tests/test_subgraph_sync.py

@@ -201,7 +201,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": None,
@@ -274,7 +274,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -377,7 +377,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -489,7 +489,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": None,
@@ -557,7 +557,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],
@@ -681,7 +681,7 @@ def test_subgraph_w_interrupt(
                                 "subgraph_counter": None,
                                 "call_counter": None,
                                 "interrupt_counter": None,
-                                "get_null_resume": None,
+                                "null_resume": None,
                                 "resume": [],
                             },
                             "checkpoint_id": c.config["configurable"]["checkpoint_id"],

libs/sdk-js/package.json

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

libs/sdk-js/src/client.ts

@@ -1022,23 +1022,13 @@ export class RunsClient<
    *
    * @param threadId The ID of the thread.
    * @param runId The ID of the run.
-   * @param options Additional options for controlling the stream behavior:
-   *   - signal: An AbortSignal that can be used to cancel the stream request
-   *   - cancelOnDisconnect: When true, automatically cancels the run if the client disconnects from the stream
-   *   - streamMode: Controls what types of events to receive from the stream (can be a single mode or array of modes)
-   *        Must be a subset of the stream modes passed when creating the run. Background runs default to having the union of all
-   *        stream modes enabled.
    * @returns An async generator yielding stream parts.
    */
   async *joinStream(
     threadId: string,
     runId: string,
     options?:
-      | {
-          signal?: AbortSignal;
-          cancelOnDisconnect?: boolean;
-          streamMode?: StreamMode | StreamMode[];
-        }
+      | { signal?: AbortSignal; cancelOnDisconnect?: boolean }
       | AbortSignal,
   ): AsyncGenerator<{ event: StreamEvent; data: any }> {
     const opts =
@@ -1053,10 +1043,7 @@ export class RunsClient<
         method: "GET",
         timeoutMs: null,
         signal: opts?.signal,
-        params: {
-          cancel_on_disconnect: opts?.cancelOnDisconnect ? "1" : "0",
-          stream_mode: opts?.streamMode,
-        },
+        params: { cancel_on_disconnect: opts?.cancelOnDisconnect ? "1" : "0" },
       }),
     );
 
@@ -1333,40 +1320,6 @@ export class StoreClient extends BaseClient {
   }
 }
 
-class UiClient extends BaseClient {
-  private static promiseCache: Record<string, Promise<unknown> | undefined> =
-    {};
-
-  private static getOrCached<T>(key: string, fn: () => Promise<T>): Promise<T> {
-    if (UiClient.promiseCache[key] != null) {
-      return UiClient.promiseCache[key] as Promise<T>;
-    }
-
-    const promise = fn();
-    UiClient.promiseCache[key] = promise;
-    return promise;
-  }
-
-  async getComponent(assistantId: string, agentName: string): Promise<string> {
-    return UiClient["getOrCached"](
-      `${this.apiUrl}-${assistantId}-${agentName}`,
-      async () => {
-        const response = await this.asyncCaller.fetch(
-          ...this.prepareFetchOptions(`/ui/${assistantId}`, {
-            headers: {
-              Accept: "text/html",
-              "Content-Type": "application/json",
-            },
-            method: "POST",
-            json: { name: agentName },
-          }),
-        );
-        return response.text();
-      },
-    );
-  }
-}
-
 export class Client<
   TStateType = DefaultValues,
   TUpdateType = TStateType,
@@ -1397,18 +1350,11 @@ export class Client<
    */
   public store: StoreClient;
 
-  /**
-   * The client for interacting with the UI.
-   * @internal Used by LoadExternalComponent and the API might change in the future.
-   */
-  public "~ui": UiClient;
-
   constructor(config?: ClientConfig) {
     this.assistants = new AssistantsClient(config);
     this.threads = new ThreadsClient(config);
     this.runs = new RunsClient(config);
     this.crons = new CronsClient(config);
     this.store = new StoreClient(config);
-    this["~ui"] = new UiClient(config);
   }
 }

libs/sdk-js/src/react-ui/client.tsx

@@ -1,5 +1,3 @@
-"use client";
-
 import { useStream } from "../react/index.js";
 import type { UIMessage } from "./types.js";
 
@@ -107,17 +105,22 @@ class ComponentStore {
 }
 
 const COMPONENT_STORE = new ComponentStore();
+const COMPONENT_PROMISE_CACHE: Record<string, Promise<string> | undefined> = {};
+
 const EXT_STORE_SYMBOL = Symbol.for("LGUI_EXT_STORE");
 const REQUIRE_SYMBOL = Symbol.for("LGUI_REQUIRE");
 
 interface LoadExternalComponentProps
   extends Pick<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> {
+  /** API URL of the LangGraph Platform */
+  apiUrl?: string;
+
+  /** ID of the assistant */
+  assistantId: string;
+
   /** Stream of the assistant */
   stream: ReturnType<typeof useStream>;
 
-  /** Namespace of UI components. Defaults to assistant ID. */
-  namespace?: string;
-
   /** UI message to be rendered */
   message: UIMessage;
 
@@ -134,9 +137,30 @@ interface LoadExternalComponentProps
   components?: Record<string, React.FunctionComponent | React.ComponentClass>;
 }
 
+function fetchComponent(
+  apiUrl: string,
+  assistantId: string,
+  agentName: string,
+): Promise<string> {
+  const cacheKey = `${apiUrl}-${assistantId}-${agentName}`;
+  if (COMPONENT_PROMISE_CACHE[cacheKey] != null) {
+    return COMPONENT_PROMISE_CACHE[cacheKey] as Promise<string>;
+  }
+
+  const request: Promise<string> = fetch(`${apiUrl}/ui/${assistantId}`, {
+    headers: { Accept: "text/html", "Content-Type": "application/json" },
+    method: "POST",
+    body: JSON.stringify({ name: agentName }),
+  }).then((a) => a.text());
+
+  COMPONENT_PROMISE_CACHE[cacheKey] = request;
+  return request;
+}
+
 export function LoadExternalComponent({
+  apiUrl = "http://localhost:2024",
+  assistantId,
   stream,
-  namespace,
   message,
   meta,
   fallback,
@@ -156,11 +180,9 @@ export function LoadExternalComponent({
   const clientComponent = components?.[message.name];
   const hasClientComponent = clientComponent != null;
 
-  const uiNamespace = namespace ?? stream.assistantId;
-  const uiClient = stream.client["~ui"];
   React.useEffect(() => {
     if (hasClientComponent) return;
-    uiClient.getComponent(uiNamespace, message.name).then((html) => {
+    fetchComponent(apiUrl, assistantId, message.name).then((html) => {
       const dom = ref.current;
       if (!dom) return;
       const root = dom.shadowRoot ?? dom.attachShadow({ mode: "open" });
@@ -171,10 +193,10 @@ export function LoadExternalComponent({
         );
       root.appendChild(fragment);
     });
-  }, [uiClient, uiNamespace, message.name, shadowRootId, hasClientComponent]);
+  }, [apiUrl, assistantId, message.name, shadowRootId, hasClientComponent]);
 
   if (hasClientComponent) {
-    return React.createElement(clientComponent, message.props);
+    return React.createElement(clientComponent, message.content);
   }
 
   return (
@@ -184,7 +206,7 @@ export function LoadExternalComponent({
       <UseStreamContext.Provider value={{ stream, meta }}>
         {state?.target != null
           ? ReactDOM.createPortal(
-              React.createElement(state.comp, message.props),
+              React.createElement(state.comp, message.content),
               state.target,
             )
           : fallback}

libs/sdk-js/src/react-ui/index.ts

@@ -2,8 +2,4 @@ import { bootstrapUiContext } from "./client.js";
 bootstrapUiContext();
 
 export { useStreamContext, LoadExternalComponent } from "./client.js";
-export {
-  uiMessageReducer,
-  type UIMessage,
-  type RemoveUIMessage,
-} from "./types.js";
+export type { UIMessage, RemoveUIMessage } from "./types.js";

libs/sdk-js/src/react-ui/server/server.ts

@@ -2,38 +2,15 @@ import { v4 as uuidv4 } from "uuid";
 import type { ComponentPropsWithoutRef, ElementType } from "react";
 import type { RemoveUIMessage, UIMessage } from "../types.js";
 
-interface MessageLike {
-  id?: string;
-}
-
-/**
- * Helper to send and persist UI messages. Accepts a map of component names to React components
- * as type argument to provide type safety. Will also write to the `options?.stateKey` state.
- *
- * @param config LangGraphRunnableConfig
- * @param options
- * @returns
- */
-export const typedUi = <Decl extends Record<string, ElementType>>(
-  config: {
-    writer?: (chunk: unknown) => void;
-    runId?: string;
-    metadata?: Record<string, unknown>;
-    tags?: string[];
-    runName?: string;
-    configurable?: {
-      __pregel_send?: (writes_: [string, unknown][]) => void;
-      [key: string]: unknown;
-    };
-  },
-  options?: {
-    /** The key to write the UI messages to. Defaults to `ui`. */
-    stateKey?: string;
-  },
-) => {
+export const typedUi = <Decl extends Record<string, ElementType>>(config: {
+  writer?: (chunk: unknown) => void;
+  runId?: string;
+  metadata?: Record<string, unknown>;
+  tags?: string[];
+  runName?: string;
+}) => {
   type PropMap = { [K in keyof Decl]: ComponentPropsWithoutRef<Decl[K]> };
-  let items: (UIMessage | RemoveUIMessage)[] = [];
-  const stateKey = options?.stateKey ?? "ui";
+  let collect: (UIMessage | RemoveUIMessage)[] = [];
 
   const runId = (config.metadata?.run_id as string | undefined) ?? config.runId;
   if (!runId) throw new Error("run_id is required");
@@ -45,39 +22,28 @@ export const typedUi = <Decl extends Record<string, ElementType>>(
     run_id: runId,
   };
 
-  const handlePush = <K extends keyof PropMap & string>(
-    message: {
-      id?: string;
-      name: K;
-      props: PropMap[K];
-      metadata?: Record<string, unknown>;
+  const create = <K extends keyof PropMap & string>(
+    name: K,
+    props: PropMap[K],
+  ): UIMessage => ({
+    type: "ui" as const,
+    id: uuidv4(),
+    name,
+    content: props,
+    additional_kwargs: metadata,
+  });
+
+  const remove = (id: string): RemoveUIMessage => ({ type: "remove-ui", id });
+
+  return {
+    create,
+    remove,
+
+    collect,
+    write: <K extends keyof PropMap & string>(name: K, props: PropMap[K]) => {
+      const evt: UIMessage = create(name, props);
+      collect.push(evt);
+      config.writer?.(evt);
     },
-    options?: { message?: MessageLike },
-  ): UIMessage => {
-    const evt: UIMessage = {
-      type: "ui" as const,
-      id: message?.id ?? uuidv4(),
-      name: message?.name,
-      props: message?.props,
-      metadata: {
-        ...metadata,
-        ...message?.metadata,
-        ...(options?.message ? { message_id: options.message.id } : null),
-      },
-    };
-    items.push(evt);
-    config.writer?.(evt);
-    config.configurable?.__pregel_send?.([[stateKey, evt]]);
-    return evt;
   };
-
-  const handleDelete = (id: string): RemoveUIMessage => {
-    const evt: RemoveUIMessage = { type: "remove-ui", id };
-    items.push(evt);
-    config.writer?.(evt);
-    config.configurable?.__pregel_send?.([[stateKey, evt]]);
-    return evt;
-  };
-
-  return { push: handlePush, delete: handleDelete, items };
 };

libs/sdk-js/src/react-ui/types.ts

@@ -3,10 +3,9 @@ export interface UIMessage {
 
   id: string;
   name: string;
-  props: Record<string, unknown>;
-  metadata: {
+  content: Record<string, unknown>;
+  additional_kwargs: {
     run_id: string;
-    message_id?: string;
     [key: string]: unknown;
   };
 }

libs/sdk-js/src/react/stream.tsx

@@ -464,11 +464,6 @@ interface UseStreamOptions<
    */
   onCustomEvent?: (
     data: CustomStreamEvent<GetCustomEventType<Bag>>["data"],
-    options: {
-      mutate: (
-        update: Partial<StateType> | ((prev: StateType) => Partial<StateType>),
-      ) => void;
-    },
   ) => void;
 
   /**
@@ -563,16 +558,6 @@ export interface UseStream<
     message: Message,
     index?: number,
   ) => MessageMetadata<StateType> | undefined;
-
-  /**
-   * LangGraph SDK client used to send request and receive responses.
-   */
-  client: Client;
-
-  /**
-   * The ID of the assistant to use.
-   */
-  assistantId: string;
 }
 
 type ConfigWithConfigurable<ConfigurableType extends Record<string, unknown>> =
@@ -642,7 +627,6 @@ export function useStream<
       options.defaultHeaders,
     ],
   );
-
   const [threadId, onThreadId] = useControllableThreadId(options);
 
   const [branch, setBranch] = useState<string>("");
@@ -850,18 +834,7 @@ export function useStream<
         }
 
         if (event === "updates") options.onUpdateEvent?.(data);
-        if (event === "custom")
-          options.onCustomEvent?.(data, {
-            mutate: (update) =>
-              setStreamValues((prev) => {
-                // should not happen
-                if (prev == null) return prev;
-                return {
-                  ...prev,
-                  ...(typeof update === "function" ? update(prev) : update),
-                };
-              }),
-          });
+        if (event === "custom") options.onCustomEvent?.(data);
         if (event === "metadata") options.onMetadataEvent?.(data);
 
         if (event === "values") setStreamValues(data);
@@ -930,9 +903,6 @@ export function useStream<
       return values;
     },
 
-    client,
-    assistantId,
-
     error,
     isLoading,
 

libs/sdk-js/src/types.messages.ts

@@ -26,7 +26,7 @@ export type AIMessage = {
   tool_calls?:
     | {
         name: string;
-        args: { [x: string]: any };
+        args: { [x: string]: { [x: string]: any } };
         id?: string | undefined;
         type?: "tool_call" | undefined;
       }[]

libs/sdk-js/yarn.lock

@@ -1177,9 +1177,9 @@ available-typed-arrays@^1.0.7:
     possible-typed-array-names "^1.0.0"
 
 axios@^1.6.7:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-1.8.2.tgz#fabe06e241dfe83071d4edfbcaa7b1c3a40f7979"
-  integrity sha512-ls4GYBm5aig9vWx8AWDSGLpnpDQRtWAfrjU+EuytuODrFBkqesN2RkOQCBzrA1RQNHw1SmRMSDDDSwzNAYQ6Rg==
+  version "1.7.7"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.7.tgz#2f554296f9892a72ac8d8e4c5b79c14a91d0a47f"
+  integrity sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==
   dependencies:
     follow-redirects "^1.15.6"
     form-data "^4.0.0"

libs/sdk-py/langgraph_sdk/client.py

@@ -1831,12 +1831,7 @@ class RunsClient:
         return await self.http.get(f"/threads/{thread_id}/runs/{run_id}/join")
 
     def join_stream(
-        self,
-        thread_id: str,
-        run_id: str,
-        *,
-        cancel_on_disconnect: bool = False,
-        stream_mode: Optional[Union[StreamMode, Sequence[StreamMode]]] = None,
+        self, thread_id: str, run_id: str, *, cancel_on_disconnect: bool = False
     ) -> AsyncIterator[StreamPart]:
         """Stream output from a run in real-time, until the run is done.
         Output is not buffered, so any output produced before this call will
@@ -1846,9 +1841,6 @@ class RunsClient:
             thread_id: The thread ID to join.
             run_id: The run ID to join.
             cancel_on_disconnect: Whether to cancel the run when the stream is disconnected.
-            stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed
-                when creating the run. Background runs default to having the union of all
-                stream modes.
 
         Returns:
             None
@@ -1857,18 +1849,14 @@ class RunsClient:
 
             await client.runs.join_stream(
                 thread_id="thread_id_to_join",
-                run_id="run_id_to_join",
-                stream_mode=["values", "debug"]
+                run_id="run_id_to_join"
             )
 
         """  # noqa: E501
         return self.http.stream(
             f"/threads/{thread_id}/runs/{run_id}/stream",
             "GET",
-            params={
-                "cancel_on_disconnect": cancel_on_disconnect,
-                "stream_mode": stream_mode,
-            },
+            params={"cancel_on_disconnect": cancel_on_disconnect},
         )
 
     async def delete(self, thread_id: str, run_id: str) -> None:
@@ -2175,7 +2163,7 @@ class StoreClient:
             "index": index,
             "ttl": ttl,
         }
-        await self.http.put("/store/items", json=_provided_vals(payload))
+        await self.http.put("/store/items", json=payload)
 
     async def get_item(
         self,
@@ -4000,14 +3988,7 @@ class SyncRunsClient:
         """  # noqa: E501
         return self.http.get(f"/threads/{thread_id}/runs/{run_id}/join")
 
-    def join_stream(
-        self,
-        thread_id: str,
-        run_id: str,
-        *,
-        stream_mode: Optional[Union[StreamMode, Sequence[StreamMode]]] = None,
-        cancel_on_disconnect: bool = False,
-    ) -> Iterator[StreamPart]:
+    def join_stream(self, thread_id: str, run_id: str) -> Iterator[StreamPart]:
         """Stream output from a run in real-time, until the run is done.
         Output is not buffered, so any output produced before this call will
         not be received here.
@@ -4015,10 +3996,6 @@ class SyncRunsClient:
         Args:
             thread_id: The thread ID to join.
             run_id: The run ID to join.
-            stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed
-                when creating the run. Background runs default to having the union of all
-                stream modes.
-            cancel_on_disconnect: Whether to cancel the run when the stream is disconnected.
 
         Returns:
             None
@@ -4027,19 +4004,11 @@ class SyncRunsClient:
 
             client.runs.join_stream(
                 thread_id="thread_id_to_join",
-                run_id="run_id_to_join",
-                stream_mode=["values", "debug"]
+                run_id="run_id_to_join"
             )
 
         """  # noqa: E501
-        return self.http.stream(
-            f"/threads/{thread_id}/runs/{run_id}/stream",
-            "GET",
-            params={
-                "stream_mode": stream_mode,
-                "cancel_on_disconnect": cancel_on_disconnect,
-            },
-        )
+        return self.http.stream(f"/threads/{thread_id}/runs/{run_id}/stream", "GET")
 
     def delete(self, thread_id: str, run_id: str) -> None:
         """Delete a run.
@@ -4338,7 +4307,7 @@ class SyncStoreClient:
             "index": index,
             "ttl": ttl,
         }
-        self.http.put("/store/items", json=_provided_vals(payload))
+        self.http.put("/store/items", json=payload)
 
     def get_item(
         self,

libs/sdk-py/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-sdk"
-version = "0.1.57"
+version = "0.1.55"
 description = "SDK for interacting with LangGraph API"
 authors = []
 license = "MIT"