Add default TTL in store & CLI (#3786)

While working on langchain-ai/langgraphjs#984 I ported the test I was
debugging over to python so I could compare behavior. Figured I might as
well add it to this codebase, as I don't think we had this particular
case covered previously.

.github/workflows/_lint.yml

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

.github/workflows/_test.yml

@@ -39,6 +39,12 @@ 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/ci.yml

@@ -39,6 +39,7 @@ jobs:
               - 'libs/checkpoint-sqlite/**'
               - 'libs/checkpoint-postgres/**'
               - 'libs/scheduler-kafka/**'
+              - 'libs/prebuilt/**'
             sdk-js:
               - 'libs/sdk-js/**'
 
@@ -56,6 +57,7 @@ jobs:
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
             "libs/scheduler-kafka",
+            "libs/prebuilt",
           ]
     if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_lint.yml
@@ -74,6 +76,7 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
+            "libs/prebuilt",
           ]
     if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_test.yml
@@ -111,6 +114,42 @@ jobs:
       - name: Run check_sdk_methods script
         run: python .github/scripts/check_sdk_methods.py
 
+  check-schema:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: "Check CLI schema hasn't changed #${{ matrix.python-version }}"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: schema-check-cli
+      - name: Install CLI dependencies
+        run: |
+          cd libs/cli
+          poetry install
+      - name: Generate schema and check for changes
+        run: |
+          cd libs/cli
+          # Create a temporary copy of the current schema
+          cp schemas/schema.json schemas/schema.current.json
+          # Generate new schema
+          poetry run python generate_schema.py
+          # Compare the new schema with the original
+          if ! diff -q schemas/schema.json schemas/schema.current.json > /dev/null; then
+            echo "Error: Langgraph.json configuration schema has changed. Please run 'poetry run python generate_schema.py' in the libs/cli directory and commit the changes."
+            diff schemas/schema.json schemas/schema.current.json
+            exit 1
+          fi
+          echo "Schema check passed - no changes detected"
+
   integration-test:
     needs: changes
     if: needs.changes.outputs.python == 'true'
@@ -177,6 +216,8 @@ jobs:
         test,
         test-langgraph,
         test-scheduler-kafka,
+        check-sdk-methods,
+        check-schema,
         integration-test,
         test-js,
       ]

.github/workflows/deploy_docs.yml

@@ -117,6 +117,7 @@ jobs:
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://academy\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://twitter.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "http://localhost:8123/.*" \
               --check-links-ignore "http://localhost:2024.*" \
@@ -143,6 +144,7 @@ jobs:
                 --check-links-ignore "http://localhost:2024.*" \
                 --check-links-ignore "http://127.0.0.1:.*" \
                 --check-links-ignore "https://x.com/.*" \
+                --check-links-ignore "https://twitter.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \
                 --check-links ${CHANGED_FILES} \

.github/workflows/release.yml

@@ -195,7 +195,11 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          if [[ "$PKG_NAME" == *checkpoint* ]]; then
+          if [[ "$PKG_NAME" == *prebuilt* ]]; then
+            poetry run pip install langgraph
+          fi
+
+          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
             # since checkpoint packages are namespace packages, import them with . convention
             # i.e. import langgraph.checkpoint or langgraph.checkpoint.sqlite
             IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/./g)"

README.md

@@ -1,6 +1,6 @@
 # 🦜🕸️LangGraph
 
-![Version](https://img.shields.io/pypi/v/langgraph)
+[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/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/)

docs/_scripts/generate_api_reference_links.py

@@ -1,9 +1,9 @@
+import ast
 import importlib
-import inspect
 import logging
 import re
 from functools import lru_cache
-from typing import List, Literal, Optional
+from typing import List, Optional
 
 from typing_extensions import TypedDict
 
@@ -39,7 +39,6 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.graph"], "langgraph.graph.message", "add_messages", "graphs"),
     (["langgraph.graph"], "langgraph.graph.state", "StateGraph", "graphs"),
     (["langgraph.graph"], "langgraph.graph.state", "CompiledStateGraph", "graphs"),
-    ([], "langgraph.types", "StreamMode", "types"),
     (["langgraph.graph"], "langgraph.constants", "START", "constants"),
     (["langgraph.graph"], "langgraph.constants", "END", "constants"),
     (["langgraph.constants"], "langgraph.types", "Send", "types"),
@@ -48,7 +47,9 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.constants"], "langgraph.types", "Command", "types"),
     (["langgraph.func"], "langgraph.func", "entrypoint", "func"),
     (["langgraph.func"], "langgraph.func", "task", "func"),
-    ([], "langgraph.types", "RetryPolicy", "types"),
+    (["langgraph.types"], "langgraph.types", "RetryPolicy", "types"),
+    (["langgraph.types"], "langgraph.types", "StreamMode", "types"),
+    (["langgraph.types"], "langgraph.types", "StreamWriter", "types"),
     ([], "langgraph.checkpoint.base", "Checkpoint", "checkpoints"),
     ([], "langgraph.checkpoint.base", "CheckpointMetadata", "checkpoints"),
     ([], "langgraph.checkpoint.base", "BaseCheckpointSaver", "checkpoints"),
@@ -68,34 +69,19 @@ WELL_KNOWN_LANGGRAPH_OBJECTS = {
 }
 
 
-def _make_regular_expression(pkg_prefix: str) -> re.Pattern:
-    if not pkg_prefix.isidentifier():
-        raise ValueError(f"Invalid package prefix: {pkg_prefix}")
-    return re.compile(
-        r"from\s+(" + pkg_prefix + "(?:_\w+)?(?:\.\w+)*?)\s+import\s+"
-        r"((?:\w+(?:,\s*)?)*"  # Match zero or more words separated by a comma+optional ws
-        r"(?:\s*\(.*?\))?)",  # Match optional parentheses block
-        re.DOTALL,  # Match newlines as well
-    )
-
-
-# Regular expression to match langchain import lines
-_IMPORT_LANGCHAIN_RE = _make_regular_expression("langchain")
-_IMPORT_LANGGRAPH_RE = _make_regular_expression("langgraph")
-
-
 @lru_cache(maxsize=10_000)
 def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
     """Get full module name using inspect, with LRU cache to memoize results."""
     try:
         module = importlib.import_module(module_path)
-        class_ = getattr(module, class_name)
-        module = inspect.getmodule(class_)
-        if module is None:
-            # For constants, inspect.getmodule() might return None
-            # In this case, we'll return the original module_path
+        symbol = getattr(module, class_name)
+        # First check the __module__ attribute on the symbol.
+        mod_name = getattr(symbol, "__module__", None)
+        # If __module__ is not set or comes from typing,
+        # assume the definition is in module_path.
+        if mod_name is None or mod_name.startswith("typing"):
             return module_path
-        return module.__name__
+        return mod_name
     except AttributeError as e:
         logger.warning(f"API Reference: Could not find module for {class_name}, {e}")
         return None
@@ -104,139 +90,128 @@ def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
         return None
 
 
-def _get_doc_title(data: str, file_name: str) -> str:
-    try:
-        return re.findall(r"^#\s*(.*)", data, re.MULTILINE)[0]
-    except IndexError:
-        pass
-    # Parse the rst-style titles
-    try:
-        return re.findall(r"^(.*)\n=+\n", data, re.MULTILINE)[0]
-    except IndexError:
-        return file_name
-
-
 class ImportInformation(TypedDict):
     imported: str  # The name of the class that was imported.
     source: str  # The full module path from which the class was imported.
     docs: str  # The URL pointing to the class's documentation.
-    title: str  # The title of the document where the import is used.
+    path: str  # The path of the file where the markdown content originated.
 
 
-def _get_imports(
-    code: str, doc_title: str, package_ecosystem: Literal["langchain", "langgraph"]
-) -> List[ImportInformation]:
-    """Get imports from the given code block.
-
-    Args:
-        code: Python code block from which to extract imports
-        doc_title: Title of the document
-        package_ecosystem: "langchain" or "langgraph". The two live in different
-            repositories and have separate documentation sites.
-
-    Returns:
-        List of import information for the given code block
-    """
-    imports = []
-
-    if package_ecosystem == "langchain":
-        pattern = _IMPORT_LANGCHAIN_RE
-    elif package_ecosystem == "langgraph":
-        pattern = _IMPORT_LANGGRAPH_RE
-    else:
-        raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
-
-    for import_match in pattern.finditer(code):
-        module = import_match.group(1)
-        if "pydantic_v1" in module:
-            continue
-        imports_str = (
-            import_match.group(2).replace("(\n", "").replace("\n)", "")
-        )  # Handle newlines within parentheses
-        # remove any newline and spaces, then split by comma
-        imported_classes = [
-            imp.strip()
-            for imp in re.split(r",\s*", imports_str.replace("\n", ""))
-            if imp.strip()
-        ]
-        for class_name in imported_classes:
-            module_path = _get_full_module_name(module, class_name)
-            if not module_path:
-                continue
-            if len(module_path.split(".")) < 2:
-                continue
-
-            if package_ecosystem == "langchain":
-                pkg = module_path.split(".")[0].replace("langchain_", "")
-                top_level_mod = module_path.split(".")[1]
-
-                url = (
-                    _LANGCHAIN_API_REFERENCE
-                    + pkg
-                    + "/"
-                    + top_level_mod
-                    + "/"
-                    + module_path
-                    + "."
-                    + class_name
-                    + ".html"
-                )
-            elif package_ecosystem == "langgraph":
-                if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
-                    # Likely not documented yet
-                    continue
-
-                source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
-                    (module, class_name)
-                ]
-                url = (
-                    _LANGGRAPH_API_REFERENCE
-                    + namespace
-                    + "/#"
-                    + source_module
-                    + "."
-                    + class_name
-                )
-            else:
-                raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
-
-            # Add the import information to our list
-            imports.append(
-                {
-                    "imported": class_name,
-                    "source": module,
-                    "docs": url,
-                    "title": doc_title,
-                }
-            )
-
-    return imports
-
-
-def get_imports(code: str, doc_title: str) -> List[ImportInformation]:
+def get_imports(code: str, path: str) -> List[ImportInformation]:
     """Retrieve all import references from the given code for specified ecosystems.
 
     Args:
         code: The source code from which to extract import references.
-        doc_title: The documentation title associated with the code.
+        path: The path of the file where the markdown content originated.
 
     Returns:
         A list of import information for each import found.
     """
-    ecosystems = ["langchain", "langgraph"]
-    all_imports = []
-    for package_ecosystem in ecosystems:
-        all_imports.extend(_get_imports(code, doc_title, package_ecosystem))
-    return all_imports
+    # Parse the code into an AST.
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return []
+
+    found_imports = []
+
+    # Walk through the AST and process ImportFrom nodes.
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            # node.module is the source module.
+            if node.module is None:
+                continue
+            for alias in node.names:
+                if not (
+                    node.module.startswith("langchain")
+                    or node.module.startswith("langgraph")
+                ):
+                    continue
+
+                found_imports.append(
+                    {
+                        "source": node.module,
+                        # alias.name is the original name even if an alias exists.
+                        "imported": alias.name,
+                    }
+                )
+
+    imports: list[ImportInformation] = []
+
+    for found_import in found_imports:
+        module = found_import["source"]
+
+        if module.startswith("langchain"):
+            # Handles things like `langchain` or `langchain_anthropic`
+            package_ecosystem = "langchain"
+        elif module.startswith("langgraph"):
+            package_ecosystem = "langgraph"
+        else:
+            continue
+
+        class_name = found_import["imported"]
+        module_path = _get_full_module_name(module, class_name)
+        if not module_path:
+            continue
+        if len(module_path.split(".")) < 2:
+            continue
+
+        if package_ecosystem == "langchain":
+            pkg = module_path.split(".")[0].replace("langchain_", "")
+            top_level_mod = module_path.split(".")[1]
+
+            url = (
+                _LANGCHAIN_API_REFERENCE
+                + pkg
+                + "/"
+                + top_level_mod
+                + "/"
+                + module_path
+                + "."
+                + class_name
+                + ".html"
+            )
+        elif package_ecosystem == "langgraph":
+            if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
+                # Likely not documented yet
+                continue
+
+            source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
+                (module, class_name)
+            ]
+            url = (
+                _LANGGRAPH_API_REFERENCE
+                + namespace
+                + "/#"
+                + source_module
+                + "."
+                + class_name
+            )
+        else:
+            raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+        # Add the import information to our list
+        imports.append(
+            {
+                "imported": class_name,
+                "source": module,
+                "docs": url,
+                "path": path,
+            }
+        )
+
+    return imports
 
 
-def update_markdown_with_imports(markdown: str) -> str:
+def update_markdown_with_imports(markdown: str, path: str) -> str:
     """Update markdown to include API reference links for imports in Python code blocks.
 
-    This function scans the markdown content for Python code blocks, extracts any imports, and appends links to their API documentation.
+    This function scans the markdown content for Python code blocks, extracts any
+    imports, and appends links to their API documentation.
 
     Args:
         markdown: The markdown content to process.
+        path: The path of the file where the markdown content originated.
 
     Returns:
         Updated markdown with API reference links appended to Python code blocks.
@@ -247,7 +222,8 @@ def update_markdown_with_imports(markdown: str) -> str:
         ```python
         from langchain.nlp import TextGenerator
         ```
-        This function will append an API reference link to the `TextGenerator` class from the `langchain.nlp` module if it's recognized.
+        This function will append an API reference link to the `TextGenerator` class
+        from the `langchain.nlp` module if it's recognized.
     """
     code_block_pattern = re.compile(
         r"(?P<indent>[ \t]*)```(?P<language>python|py)\n(?P<code>.*?)\n(?P=indent)```",

docs/_scripts/notebook_hooks.py

@@ -175,7 +175,7 @@ def _on_page_markdown_with_config(
 
     # Append API reference links to code blocks
     if add_api_references:
-        markdown = update_markdown_with_imports(markdown)
+        markdown = update_markdown_with_imports(markdown, page.file.abs_src_path)
     # Apply highlight comments to code blocks
     markdown = _highlight_code_blocks(markdown)
 

docs/_scripts/third_party_page/create_third_party_page.py

@@ -83,14 +83,18 @@ def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -
         resolved_packages, key=lambda p: p["weekly_downloads"] or 0, reverse=True
     )
     rows = [
-        "| Name | GitHub URL | Description | Weekly Downloads |",
-        "| --- | --- | --- | --- |",
+        "| Name | GitHub URL | Description | Weekly Downloads | Stars |",
+        "| --- | --- | --- | --- | --- |",
     ]
     for package in sorted_packages:
         name = f"**{package['name']}**"
         repo_url = f"[{package['repo']}](https://github.com/{package['repo']})"
+        stars_badge = (
+            f"https://img.shields.io/github/stars/{package['repo']}?style=social"
+        )
+        stars = f"![GitHub stars]({stars_badge})"
         downloads = package["weekly_downloads"] or "-"
-        row = f"| {name} | {repo_url} | {package['description']} | {downloads} |"
+        row = f"| {name} | {repo_url} | {package['description']} | {downloads} | {stars}"
         rows.append(row)
     markdown_content = MARKDOWN.format(
         library_list="\n".join(rows), langgraph_url=langgraph_url

docs/_scripts/third_party_page/packages.yml

@@ -2,16 +2,31 @@
 packages:
   - name: "trustcall"
     repo: "hinthornw/trustcall"
-    description: "Tenacious tool calling built on LangGraph"
+    description: "Tenacious tool calling built on LangGraph."
   - name: "breeze-agent"
     repo: "andrestorres123/breeze-agent"
-    description: "A streamlined research system built inspired on STORM and built on LangGraph"
+    description: "A streamlined research system built inspired on STORM and built on LangGraph."
   - name: "langgraph-supervisor"
-    repo: "langchain-ai/langgraph-supervisor"
-    description: "Build supervisor multi-agent systems with LangGraph"
+    repo: "langchain-ai/langgraph-supervisor-py"
+    description: "Build supervisor multi-agent systems with LangGraph."
   - name: "langmem"
     repo: "langchain-ai/langmem"
     description: "Build agents that learn and adapt from interactions over time."
   - name: "langchain-mcp-adapters"
     repo: "langchain-ai/langchain-mcp-adapters"
-    description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
+    description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
+  - name: "open-deep-research"
+    repo: "langchain-ai/open_deep_research"
+    description: "Open source assistant for iterative web research and report writing."
+  - name: "langgraph-swarm"
+    repo: "langchain-ai/langgraph-swarm-py"
+    description: "Build swarm-style multi-agent systems using LangGraph."
+  - name: "delve-taxonomy-generator"
+    repo: "andrestorres123/delve"
+    description: "A taxonomy generator for unstructured data"
+  - name: "nodeology"
+    repo: "xyin-anl/Nodeology"
+    description: "Enable researcher to build scientific workflows easily with simplified interface."
+  - name: "langgraph-bigtool"
+    repo: "langchain-ai/langgraph-bigtool"
+    description: "Build LangGraph agents with large numbers of tools."

docs/docs/adopters.md

@@ -1,4 +1,4 @@
-# 🦜🕸️ LangGraph Adopters
+# 🦜🕸️ Companies using LangGraph
 
 This list of companies using LangGraph and their success stories is compiled from public sources. If your company uses LangGraph, we'd love for you to share your story and add it to the list. You’re also welcome to contribute updates based on publicly available information from other companies, such as blog posts or press releases.
 
@@ -9,9 +9,11 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [AppFolio](https://www.appfolio.com/) | Real Estate | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-appfolio/) |
 | [Athena Intelligence](https://www.athenaintel.com/) | Software & Technology (GenAI Native) | Research & summarization | [Case study, 2024](https://blog.langchain.dev/customers-athena-intelligence/) |
 | [Captide](https://www.captide.co/) | Software & Technology (GenAI Native) | Data extraction | [Case study, 2025](https://blog.langchain.dev/how-captide-is-redefining-equity-research-with-agentic-workflows-built-on-langgraph-and-langsmith/) |
+| [Cisco Outshift](https://outshift.cisco.com/) | Software & Technology | DevOps | [Blog post, 2025](https://outshift.cisco.com/blog/build-react-agent-application-for-devops-tasks-using-rest-apis) |
 | [Elastic](https://www.elastic.co/) | Software & Technology | Copilot for domain-specific task | [Blog post, 2025](https://www.elastic.co/blog/elastic-security-generative-ai-features) |
 | [GitLab](https://about.gitlab.com/) | Software & Technology | Code generation | [Duo workflow docs](https://handbook.gitlab.com/handbook/engineering/architecture/design-documents/duo_workflow/) |
 | [Infor](https://infor.com/) | Software & Technology | GenAI embedded product experiences; customer support; copilot | [Case study, 2025](https://blog.langchain.dev/customers-infor/) |
+| [Klarna](https://www.klarna.com/) | Fintech | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/customers-klarna/) |
 | [Komodo Health](https://www.komodohealth.com/) | Healthcare | Copilot for domain-specific task | [Blog post](https://www.komodohealth.com/perspectives/new-gen-ai-assistant-empowers-the-enterprise/) |
 | [LinkedIn](https://www.linkedin.com/) | Social Media | Code generation; Search & discovery | [Blog post, 2025](https://www.linkedin.com/blog/engineering/ai/practical-text-to-sql-for-data-analytics); [Blog post, 2024](https://www.linkedin.com/blog/engineering/generative-ai/behind-the-platform-the-journey-to-create-the-linkedin-genai-application-tech-stack) |
 | [Minimal](https://gominimal.ai/) | E-commerce | Customer support | [Case study, 2025](https://blog.langchain.dev/how-minimal-built-a-multi-agent-customer-support-system-with-langgraph-langsmith/) |
@@ -22,4 +24,4 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [Tradestack](https://www.tradestack.uk/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-tradestack/) |
 | [Uber](https://www.uber.com/) | Transportation | Developer productivity; Code generation | [Presentation, 2024](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/); [Video, 2024](https://www.youtube.com/watch?v=8rkA5vWUE4Y) |
 | [Unify](https://www.unifygtm.com/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Blog post, 2024](https://blog.langchain.dev/unify-launches-agents-for-account-qualification-using-langgraph-and-langsmith/) |
-| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |
+| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |

docs/docs/cloud/deployment/cloud.md

@@ -92,3 +92,28 @@ Starting from the `LangGraph Platform` view...
 1. Check/uncheck checkbox to `Automatically update deployment on push to branch`.
     1. Branch creation/deletion and tag creation/deletion events will not trigger an update. Only pushes to an existing branch will trigger an update.
     1. Pushes in quick succession to a branch will not trigger subsequent updates. In the future, this functionality may be changed/improved.
+
+## Add or Remove GitHub Repositories
+
+After installing and authorizing LangChain's `hosted-langserve` GitHub app, repository access for the app can be modified to add new repositories or remove existing repositories. If a new repository is created, it may need to be added explicitly.
+
+1. From the GitHub profile, navigate to `Settings` > `Applications` > `hosted-langserve` > click `Configure`.
+1. Under `Repository access`, select `All repositories` or `Only select repositories`. If `Only select repositories` is selected, new repositories must be explicitly added.
+1. Click `Save`.
+1. When creating a new deployment, the list of GitHub repositories in the dropdown menu will be updated to reflect the repository access changes.
+
+## Whitelisting IP Addresses
+
+All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
+This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
+
+| US             | EU             |
+|----------------|----------------|
+| 35.197.29.146  | 34.13.192.67   |
+| 34.145.102.123 | 34.147.105.64  |
+| 34.169.45.153  | 34.90.22.166   |
+| 34.82.222.17   | 34.147.36.213  |
+| 35.227.171.135 | 34.32.137.113  | 
+| 34.169.88.30   | 34.91.238.184  |
+| 34.19.93.202   | 35.204.101.241 |
+| 34.19.34.50    | 35.204.48.32   |

docs/docs/cloud/deployment/semantic_search.md

@@ -17,7 +17,7 @@ This guide explains how to add semantic search to your LangGraph deployment's cr
     ...
     "store": {
         "index": {
-            "embed": "openai:text-embeddings-3-small",
+            "embed": "openai:text-embedding-3-small",
             "dims": 1536,
             "fields": ["$"]
         }
@@ -27,7 +27,7 @@ This guide explains how to add semantic search to your LangGraph deployment's cr
 
 This configuration:
 
-- Uses OpenAI's text-embeddings-3-small model for generating embeddings
+- Uses OpenAI's text-embedding-3-small model for generating embeddings
 - Sets the embedding dimension to 1536 (matching the model's output)
 - Indexes all fields in your stored data (`["$"]` means index everything, or specify specific fields like `["text", "metadata.title"]`)
 

docs/docs/cloud/deployment/setup.md

@@ -36,21 +36,20 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
 
 ```
-langgraph>=0.2.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.56,<0.4.0
+langgraph-sdk>=0.1.53
+langgraph-checkpoint>=2.0.15,<3.0
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7
 httpx>=0.25.0
 tenacity>=8.0.0
 uvicorn>=0.26.0
-sse-starlette>=2.1.0
+sse-starlette>=2.1.0,<2.2.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
+jsonschema-rs>=0.20.0
 structlog>=23.1.0
-redis>=5.0.0,<6.0.0
 ```
 
 Example `requirements.txt` file:

docs/docs/cloud/deployment/setup_pyproject.md

@@ -36,21 +36,20 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
 
 ```
-langgraph>=0.2.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.56,<0.4.0
+langgraph-sdk>=0.1.53
+langgraph-checkpoint>=2.0.15,<3.0
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7
 httpx>=0.25.0
 tenacity>=8.0.0
 uvicorn>=0.26.0
-sse-starlette>=2.1.0
+sse-starlette>=2.1.0,<2.2.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
+jsonschema-rs>=0.20.0
 structlog>=23.1.0
-redis>=5.0.0,<6.0.0
 ```
 
 Example `pyproject.toml` file:

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

@@ -0,0 +1,15 @@
+# Prompt Engineering in LangGraph Studio
+
+In LangGraph Studio you can iterate on the prompts used within your graph by utilizing the LangSmith Playground. To do so:
+
+1. Open an existing thread or create a new one.
+2. Within the thread log, any nodes that have made an LLM call will have a "View LLM Runs" button. Clicking this will open a popover with the LLM runs for that node.
+3. Select the LLM run you want to edit. This will open the LangSmith Playground with the selected LLM run.
+
+![Playground in Studio](../img/studio_playground.png){width=1200}
+
+
+
+From here you can edit the prompt, test different model configurations and re-run just this LLM call without having to re-run the entire graph. When you are happy with your changes, you can copy the updated prompt back into your graph.
+
+For more information on how to use the LangSmith Playground, see the [LangSmith Playground documentation](https://docs.smith.langchain.com/prompt_engineering/how_to_guides#playground).

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

@@ -1,10 +1,10 @@
-# Test Cloud Deployment
+# Test LangGraph Platform Deployment
 
-The LangGraph Studio UI connects directly to LangGraph Cloud deployments.
+The LangGraph Studio UI connects directly to LangGraph Platform deployments.
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `LangGraph Platform`. The `LangGraph Platform` view contains a list of existing LangGraph Platform deployments.
 1. Select an existing deployment to test with LangGraph Studio.
 1. In the top-right corner, select `Open LangGraph Studio`.
 1. [Invoke an assistant](./invoke_studio.md) or [view an existing thread](./threads_studio.md).

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

@@ -9,19 +9,18 @@ The `useStream()` React hook provides a seamless way to integrate LangGraph into
 Key features:
 
 - Messages streaming: Handle a stream of message chunks to form a complete message
-- Automatic state management for messages, loading states, and errors
+- Automatic state management for messages, interrupts, loading states, and errors
 - Conversation branching: Create alternate conversation paths from any point in the chat history
-- UI-agnostic design - bring your own components and styling
+- UI-agnostic design: bring your own components and styling
 
 Let's explore how to use `useStream()` in your React application.
 
-The `useStream()` provides a solid foundation for creating bespoke chat experiences. For pre-built chat components and interfaces, we recommend checking out [CopilotKit](https://docs.copilotkit.ai/coagents/quickstart/langgraph) and [assistant-ui](https://www.assistant-ui.com/docs/runtimes/langgraph).
-
+The `useStream()` provides a solid foundation for creating bespoke chat experiences. For pre-built chat components and interfaces, we also recommend checking out [CopilotKit](https://docs.copilotkit.ai/coagents/quickstart/langgraph) and [assistant-ui](https://www.assistant-ui.com/docs/runtimes/langgraph).
 
 ## Installation
 
 ```bash
-npm install @langchain/langgraph-sdk @langchain/langchain-core react
+npm install @langchain/langgraph-sdk @langchain/core
 ```
 
 ## Example
@@ -65,9 +64,7 @@ export default function App() {
             Stop
           </button>
         ) : (
-          <button key="submit" type="submit">
-            Send
-          </button>
+          <button keytype="submit">Send</button>
         )}
       </form>
     </div>
@@ -81,6 +78,7 @@ The `useStream()` hook takes care of all the complex state management behind the
 
 - Thread state management
 - Loading and error states
+- Interrupts
 - Message handling and updates
 - Branching support
 
@@ -134,9 +132,9 @@ We recommend storing the `threadId` in your URL's query parameters to let users
 
 ### Messages Handling
 
-To enable messages handling, you need to pass the `messagesKey` option to the `useStream()` hook. 
+The `useStream()` hook will keep track of the message chunks received from the server and concatenate them together to form a complete message. The completed message chunks can be retrieved via the `messages` property.
 
-When enabled, the `useStream()` hook will keep track of the message chunks received from the server and concatenate them together to form a complete message. The completed message chunks can be retrieved via the `messages` property.
+By default, the `messagesKey` is set to `messages`, where it will append the new messages chunks to `values["messages"]`. If you store messages in a different key, you can change the value of `messagesKey`.
 
 ```tsx
 import type { Message } from "@langchain/langgraph-sdk";
@@ -159,9 +157,49 @@ export default function HomePage() {
 }
 ```
 
-### Branching Support
+Under the hood, the `useStream()` hook will use the `streamMode: "messages-key"` to receive a stream of messages (i.e. individual LLM tokens) from any LangChain chat model invocations inside your graph nodes. Learn more about messages streaming in the [How to stream messages from your graph](./stream_messages.md) guide.
 
-To enable branching, you need to enable messages handling. Pass the `messagesKey` option to the `useStream()` hook. For each message, you can use `getMessagesMetadata()` to get the first checkpoint from which the message has been first seen. You can then create a new run from the checkpoint preceding the first seen checkpoint to create a new branch in a thread.
+### Interrupts
+
+The `useStream()` hook exposes the `interrupt` property, which will be filled with the last interrupt from the thread. You can use interrupts to:
+
+- Render a confirmation UI before executing a node
+- Wait for human input, allowing agent to ask the user with clarifying questions
+
+Learn more about interrupts in the [How to handle interrupts](../../how-tos/human_in_the_loop/wait-user-input.ipynb) guide.
+
+```tsx
+const thread = useStream<
+  { messages: Message[] },
+  { InterruptType: string }
+>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+
+if (thread.interrupt) {
+  return (
+    <div>
+      Interrupted! {thread.interrupt.value}
+
+      <button
+        type="button"
+        onClick={() => {
+          // `resume` can be any value that the agent accepts
+          thread.submit(undefined, { command: { resume: true } });
+        }}
+      >
+        Resume
+      </button>
+    </div>
+  );
+}
+```
+
+### Branching
+
+For each message, you can use `getMessagesMetadata()` to get the first checkpoint from which the message has been first seen. You can then create a new run from the checkpoint preceding the first seen checkpoint to create a new branch in a thread.
 
 A branch can be created in following ways:
 
@@ -169,23 +207,12 @@ A branch can be created in following ways:
 2. Request a regeneration of a previous assistant message.
 
 ```tsx
-/* eslint-disable @typescript-eslint/no-floating-promises */
 "use client";
 
 import type { Message } from "@langchain/langgraph-sdk";
 import { useStream } from "@langchain/langgraph-sdk/react";
-import {
-  Annotation,
-  MessagesAnnotation,
-  type StateType,
-  type UpdateType,
-} from "@langchain/langgraph/web";
 import { useState } from "react";
 
-const AgentState = Annotation.Root({
-  ...MessagesAnnotation.spec,
-});
-
 function BranchSwitcher({
   branch,
   branchOptions,
@@ -263,10 +290,7 @@ function EditMessage({
 }
 
 export default function App() {
-  const thread = useStream<
-    StateType<typeof AgentState.spec>,
-    UpdateType<typeof AgentState.spec>
-  >({
+  const thread = useStream({
     apiUrl: "http://localhost:2024",
     assistantId: "agent",
     messagesKey: "messages",
@@ -289,7 +313,7 @@ export default function App() {
                   onEdit={(message) =>
                     thread.submit(
                       { messages: [message] },
-                      { checkpoint: parentCheckpoint }
+                      { checkpoint: parentCheckpoint },
                     )
                   }
                 />
@@ -344,13 +368,11 @@ export default function App() {
 }
 ```
 
+For advanced use cases you can use the `experimental_branchTree` property to get the tree representation of the thread, which can be used to render branching controls for non-message based graphs.
+
 ### TypeScript
 
-The `useStream()` hook is fully typed to help catch errors early and provide better IDE support. You can specify types for:
-
-- State shape
-- Update format
-- Custom events
+The `useStream()` hook is friendly for apps written in TypeScript and you can specify types for the state to get better type safety and IDE support.
 
 ```tsx
 // Define your types
@@ -359,25 +381,44 @@ type State = {
   context?: Record<string, unknown>;
 };
 
-type Update = {
-  messages: Message[] | Message;
-  context?: Record<string, unknown>;
-};
-
-type CustomEvent = {
-  type: "progress" | "debug";
-  payload: unknown;
-};
-
 // Use them with the hook
-const thread = useStream<State, Update, CustomEvent>({
+const thread = useStream<State>({
   apiUrl: "http://localhost:2024",
   assistantId: "agent",
   messagesKey: "messages",
 });
 ```
 
-If you're using LangGraph.js, you can reuse your graph's annotation types:
+You can also optionally specify types for different scenarios, such as:
+
+- `ConfigurableType`: Type for the `config.configurable` property (default: `Record<string, unknown>`)
+- `InterruptType`: Type for the interrupt value - i.e. contents of `interrupt(...)` function (default: `unknown`)
+- `CustomEventType`: Type for the custom events (default: `unknown`)
+- `UpdateType`: Type for the submit function (default: `Partial<State>`)
+
+```tsx
+
+const thread = useStream<State, {
+  UpdateType: {
+    messages: Message[] | Message;
+    context?: Record<string, unknown>;
+  };
+  InterruptType: string;
+  CustomEventType: {
+    type: "progress" | "debug";
+    payload: unknown;
+  };
+  ConfigurableType: {
+    model: string;
+  };
+}>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  messagesKey: "messages",
+});
+```
+
+If you're using LangGraph.js, you can also reuse your graph's annotation types. However, make sure to only import the types of the annotation schema in order to avoid importing the entire LangGraph.js runtime (i.e. via `import type { ... }` directive).
 
 ```tsx
 import {
@@ -394,7 +435,7 @@ const AgentState = Annotation.Root({
 
 const thread = useStream<
   StateType<typeof AgentState.spec>,
-  UpdateType<typeof AgentState.spec>
+  { UpdateType: UpdateType<typeof AgentState.spec> }
 >({
   apiUrl: "http://localhost:2024",
   assistantId: "agent",
@@ -410,7 +451,7 @@ The `useStream()` hook provides several callback options to help you respond to
 - `onFinish`: Called when the stream is finished.
 - `onUpdateEvent`: Called when an update event is received.
 - `onCustomEvent`: Called when a custom event is received. See [Custom events](../../concepts/streaming.md#custom) to learn how to stream custom events.
-- `onMetadataEvent`: Called when a metadata event is received.
+- `onMetadataEvent`: Called when a metadata event is received, which contains the Run ID and Thread ID.
 
 ## Learn More
 

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

@@ -1,142 +1,147 @@
-# Use Webhooks
+# Using Webhooks
 
-You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the "webhook" parameter.
+When working with LangGraph Cloud, you may want to use webhooks to receive updates after an API call completes. Webhooks are useful for triggering actions in your service once a run has finished processing. To implement this, you need to expose an endpoint that can accept `POST` requests and pass this endpoint as a `webhook` parameter in your API request.
 
-Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.
+Currently, the SDK does not provide built-in support for defining webhook endpoints, but you can specify them manually using API requests.
 
-The following endpoints accept `webhook` as a parameter: 
+## Supported Endpoints
 
-- Create Run -> POST /thread/{thread_id}/runs
-- Create Thread Cron -> POST /thread/{thread_id}/runs/crons
-- Stream Run -> POST /thread/{thread_id}/runs/stream
-- Wait Run -> POST /thread/{thread_id}/runs/wait
-- Create Cron -> POST /runs/crons
-- Stream Run Stateless -> POST /runs/stream
-- Wait Run Stateless -> POST /runs/wait
+The following API endpoints accept a `webhook` parameter:
 
-In this example, we will show calling a webhook after streaming a run. 
+| Operation | HTTP Method | Endpoint |
+|-----------|------------|----------|
+| Create Run | `POST` | `/thread/{thread_id}/runs` |
+| Create Thread Cron | `POST` | `/thread/{thread_id}/runs/crons` |
+| Stream Run | `POST` | `/thread/{thread_id}/runs/stream` |
+| Wait Run | `POST` | `/thread/{thread_id}/runs/wait` |
+| Create Cron | `POST` | `/runs/crons` |
+| Stream Run Stateless | `POST` | `/runs/stream` |
+| Wait Run Stateless | `POST` | `/runs/wait` |
 
-## Setup
+In this guide, we’ll show how to trigger a webhook after streaming a run.
 
-First, let's setup our assistant and thread:
+## Setting Up Your Assistant and Thread
+
+Before making API calls, set up your assistant and thread.
 
 === "Python"
+```python
+from langgraph_sdk import get_client
 
-    ```python
-    from langgraph_sdk import get_client
+client = get_client(url=<DEPLOYMENT_URL>)
+assistant_id = "agent"
+thread = await client.threads.create()
+print(thread)
+```
 
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
+=== "JavaScript"
+```js
+import { Client } from "@langchain/langgraph-sdk";
 
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
+const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+const assistantID = "agent";
+const thread = await client.threads.create();
+console.log(thread);
+```
 
 === "CURL"
+```bash
+curl --request POST \
+    --url <DEPLOYMENT_URL>/assistants/search \
+    --header 'Content-Type: application/json' \
+    --data '{ "limit": 10, "offset": 0 }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
+curl --request POST \
+    --url <DEPLOYMENT_URL>/threads \
+    --header 'Content-Type: application/json' \
+    --data '{}'
+```
 
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}'
-    ```
+### Example Response
+```json
+{
+    "thread_id": "9dde5490-2b67-47c8-aa14-4bfec88af217",
+    "created_at": "2024-08-30T23:07:38.242730+00:00",
+    "updated_at": "2024-08-30T23:07:38.242730+00:00",
+    "metadata": {},
+    "status": "idle",
+    "config": {},
+    "values": null
+}
+```
 
-Output:
+## Using a Webhook with a Graph Run
 
-    {
-        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
-        'created_at': '2024-08-30T23:07:38.242730+00:00', 
-        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
-        'metadata': {}, 
-        'status': 'idle', 
-        'config': {}, 
-        'values': None
-    }
+To use a webhook, specify the `webhook` parameter in your API request. When the run completes, LangGraph Cloud sends a `POST` request to the specified webhook URL.
 
-## Use graph with a webhook
-
-To invoke a run with a webhook, we specify the `webhook` parameter with the desired endpoint when creating a run. Webhook requests are triggered by the end of a run.
-
-For example, if we can receive requests at `https://my-server.app/my-webhook-endpoint`, we can pass this to `stream`:
+For example, if your server listens for webhook events at `https://my-server.app/my-webhook-endpoint`, include this in your request:
 
 === "Python"
+```python
+input = { "messages": [{ "role": "user", "content": "Hello!" }] }
 
-    ```python
-    # create input
-    input = { "messages": [{ "role": "user", "content": "Hello!" }] }
+async for chunk in client.runs.stream(
+    thread_id=thread["thread_id"],
+    assistant_id=assistant_id,
+    input=input,
+    stream_mode="events",
+    webhook="https://my-server.app/my-webhook-endpoint"
+):
+    pass
+```
 
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode="events",
-        webhook="https://my-server.app/my-webhook-endpoint"
-    ):
-        # Do something with the stream output
-        pass
-    ```
+=== "JavaScript"
+```js
+const input = { messages: [{ role: "human", content: "Hello!" }] };
 
-=== "Javascript"
+const streamResponse = client.runs.stream(
+  thread["thread_id"],
+  assistantID,
+  {
+    input: input,
+    webhook: "https://my-server.app/my-webhook-endpoint"
+  }
+);
 
-    ```js
-    // create input
-    const input = { messages: [{ role: "human", content: "Hello!" }] };
-
-    // stream events
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input: input,
-        webhook: "https://my-server.app/my-webhook-endpoint"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      // Do something with the stream output
-    }
-    ```
+for await (const chunk of streamResponse) {
+  // Handle stream output
+}
+```
 
 === "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>,
-            "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
-            "webhook": "https://my-server.app/my-webhook-endpoint"
-        }'
-    ```
-
-The schema for the payload sent to `my-webhook-endpoint` is that of a [run](../../concepts/langgraph_server.md/#runs). See [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for more detail. Note that the run input, configuration, etc. are included in the `kwargs` field.
-
-### Signing webhook requests
-
-To sign the webhook requests, we can specify a token parameter in the webhook URL, e.g.,
-```
-https://my-server.app/my-webhook-endpoint?token=...
+```bash
+curl --request POST \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data '{
+        "assistant_id": <ASSISTANT_ID>,
+        "input": {"messages": [{"role": "user", "content": "Hello!"}]},
+        "webhook": "https://my-server.app/my-webhook-endpoint"
+    }'
 ```
 
-The server should then extract the token from the request's parameters and validate it before processing the payload.
+## Webhook Payload
+
+LangGraph Cloud sends webhook notifications in the format of a [Run](../../concepts/langgraph_server.md/#runs). See the [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for details. The request payload includes run input, configuration, and other metadata in the `kwargs` field.
+
+## Securing Webhooks
+
+To ensure only authorized requests hit your webhook endpoint, consider adding a security token as a query parameter:
+
+```
+https://my-server.app/my-webhook-endpoint?token=YOUR_SECRET_TOKEN
+```
+
+Your server should extract and validate this token before processing requests.
+
+## Testing Webhooks
+
+You can test your webhook using online services like:
+
+- **[Beeceptor](https://beeceptor.com/)** – Quickly create a test endpoint and inspect incoming webhook payloads.
+- **[Webhook.site](https://webhook.site/)** – View, debug, and log incoming webhook requests in real time.
+
+These tools help you verify that LangGraph Cloud is correctly triggering and sending webhooks to your service.
+
+---
+
+By following these steps, you can integrate webhooks into your LangGraph Cloud workflow, automating actions based on completed runs.

docs/docs/cloud/reference/cli.md

@@ -1,6 +1,6 @@
 # LangGraph CLI
 
-The LangGraph command line interface includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, you can use the CLI to deploy a local API server as an alternative to the [Studio desktop app](../../concepts/langgraph_studio.md).
+The LangGraph command line interface includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, you can use the CLI to deploy a local API server.
 
 ## Installation
 
@@ -51,6 +51,7 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
     | <span style="white-space: nowrap;">`node_version`</span>     | Specify `node_version: 20` to use LangGraph.js.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
     | <span style="white-space: nowrap;">`pip_config_file`</span>  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
     | <span style="white-space: nowrap;">`dockerfile_lines`</span> | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+    | <span style="white-space: nowrap;">`http`</span>            | HTTP server configuration with the following fields: <ul><li>`app`: Path to custom Starlette/FastAPI app (e.g., `"./src/agent/webapp.py:app"`). See [custom routes guide](../../how-tos/http/custom_routes.md).</li><li>`disable_assistants`: Disable `/assistants` routes</li><li>`disable_threads`: Disable `/threads` routes</li><li>`disable_runs`: Disable `/runs` routes</li><li>`disable_store`: Disable `/store` routes</li><li>`disable_meta`: Disable `/ok`, `/info`, `/metrics`, and `/docs` routes</li><li>`cors`: CORS configuration with fields for `allow_origins`, `allow_methods`, `allow_headers`, etc.</li></ul> |
 
 === "JS"
 

docs/docs/cloud/reference/env_var.md

@@ -2,6 +2,12 @@
 
 The LangGraph Cloud Server supports specific environment variables for configuring a deployment.
 
+## `DD_API_KEY`
+
+Specify `DD_API_KEY` (your [Datadog API Key](https://docs.datadoghq.com/account_management/api-app-keys/)) to automatically enable Datadog tracing for the deployment. Specify other [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) to configure the tracing instrumentation.
+
+If `DD_API_KEY` is specified, the application process is wrapped in the [`ddtrace-run` command](https://ddtrace.readthedocs.io/en/stable/installation_quickstart.html). Other `DD_*` environment variables (e.g. `DD_SITE`, `DD_ENV`, `DD_SERVICE`, `DD_TRACE_ENABLED`) are typically needed to properly configure the tracing instrumentation. See [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) for more details.
+
 ## `LANGCHAIN_TRACING_SAMPLING_RATE`
 
 Sampling rate for traces sent to LangSmith. Valid values: Any float between `0` and `1`.

docs/docs/concepts/breakpoints.md

@@ -83,7 +83,7 @@ node at a time or if you want to pause the graph execution at specific nodes.
 
 ### `NodeInterrupt` exception
 
-We recommend that you [**use the `interrupt` function instead**](#the-interrupt-function) of the `NodeInterrupt` exception if you're trying to implement
+We recommend that you [**use the `interrupt` function instead**][langgraph.types.interrupt] of the `NodeInterrupt` exception if you're trying to implement
 [human-in-the-loop](./human_in_the_loop.md) workflows. The `interrupt` function is easier to use and more flexible.
 
 ??? node "`NodeInterrupt` exception"

docs/docs/concepts/durable_execution.md

@@ -7,7 +7,7 @@ LangGraph's built-in [persistence](./persistence.md) layer provides durable exec
 !!! tip
 
     If you are using LangGraph with a checkpointer, you already have durable execution enabled. You can pause and resume workflows at any point, even after interruptions or failures.
-    To make the most of durable execution, ensure that your workflow is designed to be [deterministic](#determinism-and-consistent-replay) and [idempotent](#idempotency) and wrap any side effects or non-deterministic operations inside [tasks](./functional_api.md#task). You can use [tasks](./functional_api.md#task) from both the [StateGraph (Graph API)](./low_level.md) and the [Functional API](./functional_api.md).
+    To make the most of durable execution, ensure that your workflow is designed to be [deterministic](#determinism-and-consistent-replay) and [idempotent](#determinism-and-consistent-replay) and wrap any side effects or non-deterministic operations inside [tasks](./functional_api.md#task). You can use [tasks](./functional_api.md#task) from both the [StateGraph (Graph API)](./low_level.md) and the [Functional API](./functional_api.md).
 
 ## Requirements
 

docs/docs/concepts/faq.md

@@ -36,7 +36,7 @@ LangGraph is a stateful, orchestration framework that brings added control to ag
 | Concurrency Control | Simple threading                                          | Supports double-texting                                                                                |
 | Scheduling          | None                                                      | Cron scheduling                                                                                        |
 | Monitoring          | None                                                      | Integrated with LangSmith for observability                                                            |
-| IDE integration     | LangGraph Studio for Desktop                              | LangGraph Studio for Desktop & Cloud                                                                   |
+| IDE integration     | LangGraph Studio                                          | LangGraph Studio                                                                                       |
 
 ## What are my deployment options for LangGraph Platform?
 
@@ -62,3 +62,9 @@ Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that suppo
 ## Does LangGraph work with OSS LLMs?
 
 Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.
+
+## Can I use LangGraph Studio without logging to LangSmith
+
+Yes! You can use the [development version of LangGraph Server](../tutorials/langgraph-platform/local-server.md) to run the backend locally.
+This will connect to the studio frontend hosted as part of LangSmith.
+If you set an environment variable of `LANGSMITH_TRACING=false` then no traces will be sent to LangSmith.

docs/docs/concepts/human_in_the_loop.md

@@ -647,19 +647,15 @@ def node_in_parent_graph(state: State):
       This will print out
 
       ```pycon
-      --- First invocation ---
-      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 1 times
       Entered `node_in_subgraph` a total of 1 times
       Entered human_node in sub-graph a total of 1 times
-      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:0b23d72f-aaba-0329-1a59-ca4f3c8bad3b', 'human_node:25df717c-cb80-57b0-7410-44e20aac8f3c'], when='during'),)}
-
+      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:4c3a0248-21f0-1287-eacf-3002bc304db4', 'human_node:2fe86d52-6f70-2a3f-6b2f-b1eededd6348'], when='during'),)}
       --- Resuming ---
-      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 2 times
       Entered human_node in sub-graph a total of 2 times
       Got an answer of 35
-      {'parent_node': None} 
+      {'parent_node': {'state_counter': 1}}
       ```
 
 

docs/docs/concepts/index.md

@@ -7,7 +7,7 @@ description: Conceptual Guide for LangGraph
 
 This guide provides explanations of the key concepts behind the LangGraph framework and AI applications more broadly.
 
-We recommend that you go through at least the [Quick Start](../tutorials/introduction.ipynb) before diving into the conceptual guide. This will provide practical context that will make it easier to understand the concepts discussed here.
+We recommend that you go through at least the [Quickstart](../tutorials/introduction.ipynb) before diving into the conceptual guide. This will provide practical context that will make it easier to understand the concepts discussed here.
 
 The conceptual guide does not cover step-by-step instructions or specific implementation examples — those are found in the [Tutorials](../tutorials/index.md) and [How-to guides](../how-tos/index.md). For detailed reference material, please see the [API reference](../reference/index.md).
 
@@ -30,6 +30,7 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - [Streaming](streaming.md): 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](functional_api.md): `@entrypoint` and `@task` decorators that allow you to add LangGraph functionality to an existing codebase.
 - [Durable Execution](durable_execution.md): LangGraph's built-in [persistence](./persistence.md) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. 
+- [Pregel](pregel.md): Pregel is LangGraph's runtime, which is responsible for managing the execution of LangGraph applications.
 - [FAQ](faq.md): Frequently asked questions about LangGraph.
 
 ## LangGraph Platform
@@ -47,6 +48,7 @@ The LangGraph Platform offers a few different deployment options described in th
 
 - [Why LangGraph Platform?](./langgraph_platform.md): The LangGraph platform is an opinionated way to deploy and manage LangGraph applications. This guide provides an overview of the key features and concepts behind LangGraph Platform.
 - [Platform Architecture](./platform_architecture.md): A high-level overview of the architecture of the LangGraph Platform.
+- [Scalability and Resilience](./scalability_and_resilience.md): LangGraph Platform is designed to be scalable and resilient. This document explains how the platform achieves this.
 - [Deployment Options](./deployment_options.md): LangGraph Platform offers four deployment options: [Self-Hosted Lite](./self_hosted.md#self-hosted-lite), [Self-Hosted Enterprise](./self_hosted.md#self-hosted-enterprise), [bring your own cloud (BYOC)](./bring_your_own_cloud.md), and [Cloud SaaS](./langgraph_cloud.md). This guide explains the differences between these options, and which Plans they are available on.
 - [Plans](./plans.md): LangGraph Platforms offer three different plans: Developer, Plus, Enterprise. This guide explains the differences between these options, what deployment options are available for each, and how to sign up for each one.
 - [Template Applications](./template_applications.md): Reference applications designed to help you get started quickly when building with LangGraph.

docs/docs/concepts/langgraph_cli.md

@@ -4,7 +4,7 @@
     - [LangGraph Platform](./langgraph_platform.md)
     - [LangGraph Server](./langgraph_server.md)
 
-The LangGraph CLI is a multi-platform command-line tool for building and running the [LangGraph API server](./langgraph_server.md) locally. This offers an alternative to the [LangGraph Studio desktop app](./langgraph_studio.md) for developing and testing agents across all major operating systems (Linux, Windows, MacOS). The resulting server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
+The LangGraph CLI is a multi-platform command-line tool for building and running the [LangGraph API server](./langgraph_server.md) locally. The resulting server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
 
 ## Installation
 

docs/docs/concepts/langgraph_cloud.md

@@ -80,6 +80,22 @@ A high-level diagram of a Cloud SaaS deployment.
 
 ![diagram](img/langgraph_cloud_architecture.png)
 
+## Whitelisting IP Addresses
+
+All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
+This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
+
+| US             | EU             |
+|----------------|----------------|
+| 35.197.29.146  | 34.13.192.67   |
+| 34.145.102.123 | 34.147.105.64  |
+| 34.169.45.153  | 34.90.22.166   |
+| 34.82.222.17   | 34.147.36.213  |
+| 35.227.171.135 | 34.32.137.113  | 
+| 34.169.88.30   | 34.91.238.184  |
+| 34.19.93.202   | 35.204.101.241 |
+| 34.19.34.50    | 35.204.48.32   |
+
 ## Related
 
 - [Deployment Options](./deployment_options.md)

docs/docs/concepts/langgraph_studio.md

@@ -7,7 +7,7 @@
 
 LangGraph Studio offers a new way to develop LLM applications by providing a specialized agent IDE that enables visualization, interaction, and debugging of complex agentic applications.
 
-With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with LangSmith allowing you to  collaborate with teammates to debug failure modes.
+With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with LangSmith allowing you to collaborate with teammates to debug failure modes.
 
 ![](img/lg_studio.png)
 
@@ -15,7 +15,7 @@ With visual graphs and the ability to edit state, you can better understand agen
 
 The key features of LangGraph Studio are:
 
-- Visualizes your graph
+- Visualize your graphs
 - Test your graph by running it from the UI
 - Debug your agent by [modifying its state and rerunning](human_in_the_loop.md)
 - Create and manage [assistants](assistants.md)
@@ -23,86 +23,54 @@ The key features of LangGraph Studio are:
 - View and manage [long term memory](memory.md)
 - Add node input/outputs to [LangSmith](https://smith.langchain.com/) datasets for testing
 
-## Types
+## Getting started
 
-### Development server with web UI
+There are two ways to connect your LangGraph app with the studio:
 
-You can [run a local in-memory development server](../tutorials/langgraph-platform/local-server.md) that can be used to connect a local LangGraph app with a web version of the studio.
-For example, if you start the local server with `langgraph dev` (running at `http://127.0.0.1:2024` by default), you can connect to the studio by navigating to:
+### Deployed Application
+
+If you have deployed your LangGraph application on LangGraph Platform, you can access the studio as part of that deployment. To do so, navigate to the deployment in LangGraph Platform within the LangSmith UI and click the "LangGraph Studio" button.
+
+### Local Development Server
+
+If you have a LangGraph application that is [running locally in-memory](../tutorials/langgraph-platform/local-server.md), you can connect it to LangGraph Studio in the browser within LangSmith.
+
+By default, starting the local server with `langgraph dev` will run the server at `http://127.0.0.1:2024` and automatically open Studio in your browser. However, you can also manually connect to Studio by either:
+
+1. In LangGraph Platform, clicking the "LangGraph Studio" button and entering the server URL in the dialog that appears.
+
+   or
+
+2. Navigating to the URL in your browser:
 
 ```
 https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
 ```
 
-See [instructions here](../cloud/reference/cli.md#dev) for more information.
+## Related
 
-The web UI version of the studio will connect to your locally running server — your agent is still running locally and never leaves your device.
+For more information please see the following:
 
-### Cloud studio
+- [LangGraph Studio how-to guides](../how-tos/index.md#langgraph-studio)
+- [LangGraph CLI Documentation](../cloud/reference/cli.md)
 
-If you have deployed your LangGraph application on LangGraph Platform (Cloud), you can access the studio as part of that
-
-### Desktop app
-
-LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users.
-
-While in Beta, LangGraph Studio is available for free to all [LangSmith](https://smith.langchain.com/) users on any plan tier.
-
-## Studio FAQs
+## LangGraph Studio FAQs
 
 ### Why is my project failing to start?
 
-There are a few reasons that your project might fail to start, here are some of the most common ones.
-
-#### Docker issues (desktop only)
-
-LangGraph Studio (desktop) requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
-
-#### Configuration or environment issues
-
-Another reason your project might fail to start is because your configuration file is defined incorrectly, or you are missing required environment variables.
-
-!!! Important "Note (desktop only)"
-
-    LangGraph Studio Desktop automatically populates `LANGCHAIN_*` environment variables for license verification and tracing, regardless of the contents of the `.env` file. All other environment variables defined in `.env` will be read as normal.
-
-#### Incorrect data region (desktop only)
-
-If you receive a license verification error when attempting to start the LangGraph Server, you may be logged into the incorrect LangSmith data region. Ensure that you're logged into the correct LangSmith data region and ensure that the LangSmith account has access to LangGraph platform.
-
-1. In the top right-hand corner, click the user icon and select `Logout`.
-1. At the login screen, click the `Data Region` dropdown menu and select the appropriate data region. Then click `Login to LangSmith`.
+A project may fail to start if the configuration file is defined incorrectly, or if required environment variables are missing. See [here](../cloud/reference/cli.md#configuration-file) for how your configuration file should be defined.
 
 ### How does interrupt work?
 
 When you select the `Interrupts` dropdown and select a node to interrupt the graph will pause execution before and after (unless the node goes straight to `END`) that node has run. This means that you will be able to both edit the state before the node is ran and the state after the node has ran. This is intended to allow developers more fine-grained control over the behavior of a node and make it easier to observe how the node is behaving. You will not be able to edit the state after the node has ran if the node is the final node in the graph.
 
-### How do I reload the app?  (desktop only)
+For more information on interrupts and human in the loop, see [here](./human_in_the_loop.md).
 
-If you would like to reload the app, don't use Command+R as you might normally do. Instead, close and reopen the app for a full refresh.
-
-### How does automatic rebuilding work?  (desktop only)
-
-One of the key features of LangGraph Studio is that it automatically rebuilds your image when you change the source code. This allows for a super fast development and testing cycle which makes it easy to iterate on your graph. There are two different ways that LangGraph rebuilds your image: either by editing the image or completely rebuilding it.
-
-#### Rebuilds from source code changes
-
-If you modified the source code only (no configuration or dependency changes!) then the image does not require a full rebuild, and LangGraph Studio will only update the relevant parts. The UI status in the bottom left will switch from `Online` to `Stopping` temporarily while the image gets edited. The logs will be shown as this process is happening, and after the image has been edited the status will change back to `Online` and you will be able to run your graph with the modified code!
-
-
-#### Rebuilds from configuration or dependency changes
-
-If you edit your graph configuration file (`langgraph.json`) or the dependencies (either `pyproject.toml` or `requirements.txt`) then the entire image will be rebuilt. This will cause the UI to switch away from the graph view and start showing the logs of the new image building process. This can take a minute or two, and once it is done your updated image will be ready to use!
-
-### Why is my graph taking so long to startup?  (desktop only)
-
-The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.
-
-## Why are extra edges showing up in my graph?
+### Why are extra edges showing up in my graph?
 
 If you don't define your conditional edges carefully, you might notice extra edges appearing in your graph. This is because without proper definition, LangGraph Studio assumes the conditional edge could access all other nodes. In order for this to not be the case, you need to be explicit about how you define the nodes the conditional edge routes to. There are two ways you can do this:
 
-### Solution 1: Include a path map
+#### Solution 1: Include a path map
 
 The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary or array that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
 
@@ -120,7 +88,7 @@ The first way to solve this is to add path maps to your conditional edges. A pat
 
 In this case, the routing function returns either True or False, which map to `node_b` and `node_c` respectively.
 
-### Solution 2: Update the typing of the router (Python only)
+#### Solution 2: Update the typing of the router (Python only)
 
 Instead of passing a path map, you can also be explicit about the typing of your routing function by specifying the nodes it can map to using the `Literal` python definition. Here is an example of how to define a routing function in that way:
 
@@ -132,9 +100,48 @@ def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
         return "node_c"
 ```
 
+### Studio Desktop FAQs
 
-## Related
+!!! warning "Deprecation Warning"
+    In order to support a wider range of platforms and users, we now recommend following the above instructions to connect to LangGraph Studio using the development server instead of the desktop app.
 
-For more information please see the following:
+The LangGraph Studio Desktop App is a standalone application that allows you to connect to your LangGraph application and visualize and interact with your graph. It is available for MacOS only and requires Docker to be installed.
 
-*  [LangGraph Studio how-to guides](../how-tos/index.md#langgraph-studio)
+#### Why is my project failing to start?
+
+In addition to the reasons listed above, for the desktop app there are a few more reasons that your project might fail to start:
+
+!!! Important "Note "
+
+    LangGraph Studio Desktop automatically populates `LANGCHAIN_*` environment variables for license verification and tracing, regardless of the contents of the `.env` file. All other environment variables defined in `.env` will be read as normal.
+
+##### Docker issues
+
+LangGraph Studio (desktop) requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
+
+##### Incorrect data region
+
+If you receive a license verification error when attempting to start the LangGraph Server, you may be logged into the incorrect LangSmith data region. Ensure that you're logged into the correct LangSmith data region and ensure that the LangSmith account has access to LangGraph platform.
+
+1. In the top right-hand corner, click the user icon and select `Logout`.
+1. At the login screen, click the `Data Region` dropdown menu and select the appropriate data region. Then click `Login to LangSmith`.
+
+### How do I reload the app?
+
+If you would like to reload the app, don't use Command+R as you might normally do. Instead, close and reopen the app for a full refresh.
+
+### How does automatic rebuilding work?
+
+One of the key features of LangGraph Studio is that it automatically rebuilds your image when you change the source code. This allows for a super fast development and testing cycle which makes it easy to iterate on your graph. There are two different ways that LangGraph rebuilds your image: either by editing the image or completely rebuilding it.
+
+#### Rebuilds from source code changes
+
+If you modified the source code only (no configuration or dependency changes!) then the image does not require a full rebuild, and LangGraph Studio will only update the relevant parts. The UI status in the bottom left will switch from `Online` to `Stopping` temporarily while the image gets edited. The logs will be shown as this process is happening, and after the image has been edited the status will change back to `Online` and you will be able to run your graph with the modified code!
+
+#### Rebuilds from configuration or dependency changes
+
+If you edit your graph configuration file (`langgraph.json`) or the dependencies (either `pyproject.toml` or `requirements.txt`) then the entire image will be rebuilt. This will cause the UI to switch away from the graph view and start showing the logs of the new image building process. This can take a minute or two, and once it is done your updated image will be ready to use!
+
+### Why is my graph taking so long to startup?
+
+The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.

docs/docs/concepts/low_level.md

@@ -310,7 +310,7 @@ graph.add_conditional_edges(START, routing_function, {True: "node_b", False: "no
 
 ## `Send`
 
-By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
+By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common example of this is with [map-reduce](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/) design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
 
 To support this design pattern, LangGraph supports returning [`Send`][langgraph.types.Send] objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node.
 

docs/docs/concepts/multi_agent.md

@@ -112,6 +112,7 @@ In this architecture, agents are defined as graph nodes. Each agent can communic
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
+from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()
@@ -158,6 +159,7 @@ In this architecture, we define agents as nodes and add a supervisor node (LLM)
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
+from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()

docs/docs/concepts/pregel.md

@@ -0,0 +1,347 @@
+# LangGraph's Runtime (Pregel)
+
+[Pregel][langgraph.pregel.Pregel] implements LangGraph's runtime, managing the execution of LangGraph applications.
+
+Compiling a [StateGraph][langgraph.graph.StateGraph] or creating an [entrypoint][langgraph.func.entrypoint] produces a [Pregel][langgraph.pregel.Pregel] instance that can be invoked with input.
+
+This guide explains the runtime at a high level and provides instructions for directly implementing applications with Pregel.
+
+> **Note:** The [Pregel][langgraph.pregel.Pregel] runtime is named after [Google's Pregel algorithm](https://research.google/pubs/pub37252/), which describes an efficient method for large-scale parallel computation using graphs.
+
+## Overview
+
+In LangGraph, Pregel combines [**actors**](https://en.wikipedia.org/wiki/Actor_model) and **channels** into a single application. **Actors** read data from channels and write data to channels. Pregel organizes the execution of the application into multiple steps, following the **Pregel Algorithm**/**Bulk Synchronous Parallel** model.
+
+Each step consists of three phases:
+
+- **Plan**: Determine which **actors** to execute in this step. For example, in the first step, select the **actors** that subscribe to the special **input** channels; in subsequent steps, select the **actors** that subscribe to channels updated in the previous step.
+- **Execution**: Execute all selected **actors** in parallel, until all complete, or one fails, or a timeout is reached. During this phase, channel updates are invisible to actors until the next step.
+- **Update**: Update the channels with the values written by the **actors** in this step.
+
+Repeat until no **actors** are selected for execution, or a maximum number of steps is reached.
+
+## Actors 
+
+An **actor** is a [PregelNode][langgraph.pregel.read.PregelNode]. It subscribes to channels, reads data from them, and writes data to them. It can be thought of as an **actor** in the Pregel algorithm. [PregelNodes][langgraph.pregel.read.PregelNode] implement LangChain's Runnable interface.
+
+## Channels
+
+Channels are used to communicate between actors (PregelNodes). Each channel has a value type, an update type, and an update function – which takes a sequence of updates and modifies the stored value. Channels can be used to send data from one chain to another, or to send data from a chain to itself in a future step. LangGraph provides a number of built-in channels:
+
+### Basic channels: LastValue and Topic
+
+- [LastValue][langgraph.channels.LastValue]: The default channel, stores the last value sent to the channel, useful for input and output values, or for sending data from one step to the next.
+- [Topic][langgraph.channels.Topic]: A configurable PubSub Topic, useful for sending multiple values between **actors**, or for accumulating output. Can be configured to deduplicate values or to accumulate values over the course of multiple steps.
+
+### Advanced channels: Context and BinaryOperatorAggregate
+
+- `Context`: exposes the value of a context manager, managing its lifecycle. Useful for accessing external resources that require setup and/or teardown; e.g., `client = Context(httpx.Client)`.
+- [BinaryOperatorAggregate][langgraph.channels.BinaryOperatorAggregate]: stores a persistent value, updated by applying a binary operator to the current value and each update sent to the channel, useful for computing aggregates over multiple steps; e.g.,`total = BinaryOperatorAggregate(int, operator.add)`
+
+## Examples
+
+While most users will interact with Pregel through the [StateGraph][langgraph.graph.StateGraph] API or 
+the [entrypoint][langgraph.func.entrypoint] decorator, it is possible to interact with Pregel directly.
+
+Below are a few different examples to give you a sense of the Pregel API.
+
+=== "Single node"
+
+    ```python
+
+    from langgraph.channels import EphemeralValue
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
+    )
+
+    app = Pregel(
+        nodes={"node1": node1},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+        },
+        input_channels=["a"],
+        output_channels=["b"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```con
+    {'b': 'foofoo'}
+    ```
+
+=== "Multiple nodes"
+
+    ```python
+    from langgraph.channels import LastValue, EphemeralValue
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | Channel.write_to("c")
+    )
+
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": LastValue(str),
+            "c": EphemeralValue(str),
+        },
+        input_channels=["a"],
+        output_channels=["b", "c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```con
+    {'b': 'foofoo', 'c': 'foofoofoofoo'}
+    ```
+
+=== "Topic"
+
+    ```python
+    from langgraph.channels import EphemeralValue, Topic
+    from langgraph.pregel import Pregel, Channel 
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
+    )
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+            "c": Topic(str, accumulate=True),
+        },
+        input_channels=["a"],
+        output_channels=["c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+
+    ```pycon
+    {'c': ['foofoo', 'foofoofoofoo']}
+    ```
+
+=== "BinaryOperatorAggregate"
+
+    This examples demonstrates how to use the BinaryOperatorAggregate channel to implement a reducer.
+
+    ```python
+    from langgraph.channels import EphemeralValue, BinaryOperatorAggregate
+    from langgraph.pregel import Pregel, Channel
+
+
+    node1 = (
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
+    )
+
+    node2 = (
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
+    )
+
+    def reducer(current, update):
+        if current:
+            return current + " | " + "update"
+        else:
+            return update
+
+    app = Pregel(
+        nodes={"node1": node1, "node2": node2},
+        channels={
+            "a": EphemeralValue(str),
+            "b": EphemeralValue(str),
+            "c": BinaryOperatorAggregate(str, operator=reducer),
+        },
+        input_channels=["a"],
+        output_channels=["c"],
+    )
+
+    app.invoke({"a": "foo"})
+    ```
+    
+    
+=== "Cycle"
+
+    This example demonstrates how to introduce a cycle in the graph, by having
+    a chain write to a channel it subscribes to. Execution will continue
+    until a None value is written to the channel.
+
+    ```python
+    from langgraph.channels import EphemeralValue
+    from langgraph.pregel import Pregel, Channel, ChannelWrite, ChannelWriteEntry
+
+    example_node = (
+        Channel.subscribe_to("value")
+        | (lambda x: x + x if len(x) < 10 else None)
+        | ChannelWrite(writes=[ChannelWriteEntry(channel="value", skip_none=True)])
+    )
+
+    app = Pregel(
+        nodes={"example_node": example_node},
+        channels={
+            "value": EphemeralValue(str),
+        },
+        input_channels=["value"],
+        output_channels=["value"],
+    )
+
+    app.invoke({"value": "a"})
+    ```
+
+    ```pycon
+    {'value': 'aaaaaaaaaaaaaaaa'}
+    ```
+
+## High-level API
+
+LangGraph provides two high-level APIs for creating a Pregel application: the [StateGraph (Graph API)](./low_level.md) and the [Functional API](functional_api.md).
+
+
+=== "StateGraph (Graph API)"
+
+    The [StateGraph (Graph API)][langgraph.graph.StateGraph] is a higher-level abstraction that simplifies the creation of Pregel applications. It allows you to define a graph of nodes and edges. When you compile the graph, the StateGraph API automatically creates the Pregel application for you.
+
+    ```python
+    from typing import TypedDict, Optional
+
+    from langgraph.constants import START
+    from langgraph.graph import StateGraph
+
+    class Essay(TypedDict):
+        topic: str
+        content: Optional[str]
+        score: Optional[float]
+
+    def write_essay(essay: Essay):
+        return {
+            "content": f"Essay about {essay['topic']}",
+        }
+
+    def score_essay(essay: Essay):
+        return {
+            "score": 10
+        }
+
+    builder = StateGraph(Essay)
+    builder.add_node(write_essay)
+    builder.add_node(score_essay)
+    builder.add_edge(START, "write_essay")
+
+    # Compile the graph. 
+    # This will return a Pregel instance.
+    graph = builder.compile()
+    ```
+
+    The compiled Pregel instance will be associated with a list of nodes and channels. You can inspect the nodes and channels by printing them.
+
+    ```python
+    print(graph.nodes)
+    ```
+
+    You will see something like this:
+
+    ```pycon 
+    {'__start__': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1810>,
+     'write_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba14d0>,
+     'score_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1710>}
+     ```
+
+    ```python
+    print(graph.channels)
+    ```
+
+    You should see something like this
+
+    ```pycon
+    {'topic': <langgraph.channels.last_value.LastValue at 0x7d05e3294d80>,
+     'content': <langgraph.channels.last_value.LastValue at 0x7d05e3295040>,
+     'score': <langgraph.channels.last_value.LastValue at 0x7d05e3295980>,
+     '__start__': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3297e00>,
+     'write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32960c0>,
+     'score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ab80>,
+     'branch:__start__:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32941c0>,
+     'branch:__start__:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d88800>,
+     'branch:write_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3295ec0>,
+     'branch:write_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ac00>,
+     'branch:score_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d89700>,
+     'branch:score_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b400>,
+     'start:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b280>}
+    ```
+
+=== "Functional API"
+
+    In the [Functional API](functional_api.md), you can use an [`entrypoint`][langgraph.func.entrypoint] to create
+    a Pregel application. The `entrypoint` decorator allows you to define a function that takes input and returns output. 
+
+    ```python
+    from typing import TypedDict, Optional
+
+    from langgraph.checkpoint.memory import InMemorySaver
+    from langgraph.func import entrypoint
+
+    class Essay(TypedDict):
+        topic: str
+        content: Optional[str]
+        score: Optional[float]
+
+
+    checkpointer = InMemorySaver()
+
+    @entrypoint(checkpointer=checkpointer)
+    def write_essay(essay: Essay):
+        return {
+            "content": f"Essay about {essay['topic']}",
+        }
+
+    print("Nodes: ")
+    print(write_essay.nodes)
+    print("Channels: ")
+    print(write_essay.channels)
+    ```
+
+    ```pycon
+    Nodes: 
+    {'write_essay': <langgraph.pregel.read.PregelNode object at 0x7d05e2f9aad0>}
+    Channels: 
+    {'__start__': <langgraph.channels.ephemeral_value.EphemeralValue object at 0x7d05e2c906c0>, '__end__': <langgraph.channels.last_value.LastValue object at 0x7d05e2c90c40>, '__previous__': <langgraph.channels.last_value.LastValue object at 0x7d05e1007280>}
+    ```

docs/docs/concepts/scalability_and_resilience.md

@@ -0,0 +1,35 @@
+# LangGraph Platform: Scalability & Resilience
+
+LangGraph Platform is designed to scale horizontally with your workload. Each instance of the service is stateless, and keeps no resources in memory. The service is designed to gracefully handle new instances being added or removed, including hard shutdown cases.
+
+## Server scalability
+
+As you add more instances to a service, they will share the HTTP load as long as an appropriate load balancer mechanism is placed in front of them. In most deployment modalities we configure a load balancer for the service automatically. In the “self-hosted without control plane” modality it’s your responsibility to add a load balancer. Since the instances are stateless any load balancing strategy will work, no session stickiness is needed, or recommended. Any instance of the server can communicate with any queue instance (through Redis PubSub), meaning that requests to cancel or stream an in-progress run can be handled by any arbitrary instance.
+
+## Queue scalability
+
+As you add more instances to a service, they will increase run throughput linearly, as each instance is configured to handle a set number of concurrent runs (by default 10). Each attempt for each run will be handled by a single instance, with exactly-once semantics enforced through Postgres’s MVCC model (refer to section below for crash resilience details). Attempts that fail due to transient database errors are retried up to 3 times. We do not make use of long-lived transactions or locks, this enables us to make more efficient use of Postgres resources.
+
+## Resilience
+
+While a run is being handled by a queue instance, a periodic heartbeat timestamp will be recorded in Redis by that queue worker.
+
+When a graceful shutdown request is received (SIGINT) an instance enters shutdown mode, which
+
+- stops accepting new HTTP requests
+- gives any in-progress runs a limited number of seconds to finish (if not finished it will be put back in the queue)
+- stops the instance from picking up more runs from the queue
+
+If a hard shutdown occurs, eg. due to a server crash, or an infra failure, any runs that were in progress will be picked up by a periodic sweeper task that looks for in-progress runs that have breached their heartbeat window, which will put them back in the queue for another instance to pick them up.
+
+## Postgres resilience
+
+For deployment modalities where we manage the Postgres database we have periodic backups, continuously replicated standby replicas for automatic failover. Optionally, on request, we can also setup read replicas as well as other advanced failover capabilities.
+
+All communication with Postgres implements retries for retry-able errors. If Postgres is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of the Postgres instance will switch traffic to the failover replica. If the failover replica also fails before the primary is brought back online the service would become unavailable.
+
+## Redis resilience
+
+All data that requires durable storage is stored in Postgres, not Redis. Redis is used only for ephemeral metadata, and communication between instances. Refer to the [architecture](./platform_architecture.md) page for more details on how we use Redis. Therefore we place no durability requirements on Redis.
+
+All communication with Redis implements retries for retry-able errors. If Redis is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of Redis will render the LGP service unavailable.

docs/docs/how-tos/http/custom_lifespan.md

@@ -0,0 +1,82 @@
+# How to add custom lifespan events
+
+When deploying agents on the LangGraph platform, you often need to initialize resources like database connections when your server starts up, and ensure they're properly closed when it shuts down. Lifespan events let you hook into your server's startup and shutdown sequence to handle these critical setup and teardown tasks.
+
+This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom lifespan events in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following lifespan code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # for example...
+    engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/db")
+    # Create reusable session factory
+    async_session = sessionmaker(engine, class_=AsyncSession)
+    # Store in app state
+    app.state.db_session = async_session
+    yield
+    # Clean up connections
+    await engine.dispose()
+
+# highlight-next-line
+app = FastAPI(lifespan=lifespan)
+
+# ... can add custom routes if needed.
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+You should see your startup message printed when the server starts, and your cleanup message when you stop it with Ctrl+C.
+
+## Deploying
+
+You can deploy your app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added lifespan events to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or [custom middleware](./custom_middleware.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_middleware.md

@@ -0,0 +1,75 @@
+# How to add custom middleware
+
+When deploying agents on the LangGraph platform, you can add custom middleware to your server to handle cross-cutting concerns like logging request metrics, injecting or checking headers, and enforcing security policies without modifying core server logic. This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
+
+Adding middleware lets you intercept and modify requests and responses globally across your deployment, whether they're hitting your custom endpoints or the built-in LangGraph Platform APIs.
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom middleware in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following middleware code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from fastapi import FastAPI, Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+# highlight-next-line
+app = FastAPI()
+
+class CustomHeaderMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response = await call_next(request)
+        response.headers['X-Custom-Header'] = 'Hello from middleware!'
+        return response
+
+# Add the middleware to the app
+app.add_middleware(CustomHeaderMiddleware)
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+Now any request to your server will include the custom header `X-Custom-Header` in its response.
+
+## Deploying
+
+You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added custom middleware to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or define [custom lifespan events](./custom_lifespan.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_routes.md

@@ -0,0 +1,78 @@
+# How to add custom routes
+
+When deploying agents on the LangGraph platform, your server automatically exposes routes for creating runs and threads, interacting with the long-term memory store, managing configurable assistants, and other core functionality ([see all default API endpoints](../../cloud/reference/api/api_ref.md)).
+
+You can add custom routes by providing your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps). You make LangGraph Platform aware of this by providing a path to the app in your `langgraph.json` configuration file. (`"http": {"app": "path/to/app.py:app"}`).
+
+Defining a custom app object lets you add any routes you'd like, so you can do anything from adding a `/login` endpoint to writing an entire full-stack web-app, all deployed in a single LangGraph deployment.
+
+Below is an example using FastAPI.
+
+???+ note "Python only"
+
+    We currently only support custom authentication and authorization in Python deployments with `langgraph-api>=0.0.26`.
+
+## Create app
+
+Starting from an **existing** LangGraph Platform application, add the following custom route code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
+
+```bash
+langgraph new --template=new-langgraph-project-python my_new_project
+```
+
+Once you have a LangGraph project, add the following app code:
+
+```python
+# ./src/agent/webapp.py
+from fastapi import FastAPI
+
+# highlight-next-line
+app = FastAPI()
+
+
+@app.get("/hello")
+def read_root():
+    return {"Hello": "World"}
+
+```
+
+## Configure `langgraph.json`
+
+Add the following to your `langgraph.json` file. Make sure the path points to the `app.py` file you created above.
+
+```json
+{
+  "dependencies": ["."],
+  "graphs": {
+    "agent": "./src/agent/graph.py:graph"
+  },
+  "env": ".env",
+  "http": {
+    "app": "./src/agent/webapp.py:app"
+  }
+  // Other configuration options like auth, store, etc.
+}
+```
+
+## Start server
+
+Test the server out locally:
+
+```bash
+langgraph dev --no-browser
+```
+
+If you navigate to `localhost:2024/hello` in your browser (2024 is the default development port), you should see the `hello` endpoint returning `{"Hello": "World"}`.
+
+
+!!! note "Shadowing default endpoints"
+
+    The routes you create in the app are given priority over the system defaults, meaning you can shadow and redefine the behavior of any default endpoint.
+
+## Deploying
+
+You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
+
+## Next steps
+
+Now that you've added a custom route to your deployment, you can use this same technique to further customize how your server behaves, such as defining custom [custom middleware](./custom_middleware.md) and [custom lifespan events](./custom_lifespan.md). 

docs/docs/how-tos/index.md

@@ -59,12 +59,10 @@ LangGraph makes it easy to manage conversation [memory](../concepts/memory.md) i
 [Human-in-the-loop](../concepts/human_in_the_loop.md) 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.
 
-
 Key workflows:
 
 - [How to wait for user input](human_in_the_loop/wait-user-input.ipynb): 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](human_in_the_loop/review-tool-calls.ipynb): Incorporate human-in-the-loop for reviewing/editing/accepting tool call requests before they executed using the `interrupt` function.
- 
 
 Other methods:
 
@@ -215,6 +213,12 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
 - [How to add custom authentication](./auth/custom_auth.md)
 - [How to update the security schema of your OpenAPI spec](./auth/openapi_security.md)
 
+### Modifying the API
+
+- [How to add custom routes](./http/custom_routes.md)
+- [How to add custom middleware](./http/custom_middleware.md)
+- [How to add custom lifespan events](./http/custom_lifespan.md)
+
 ### Assistants
 
 [Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -284,12 +288,12 @@ Graph execution can take a while, and sometimes users may change their mind abou
 
 LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
 
-- [How to connect to a LangGraph Cloud deployment](../cloud/how-tos/test_deployment.md)
+- [How to connect to a LangGraph Platform deployment](../cloud/how-tos/test_deployment.md)
 - [How to connect to a local dev server](../how-tos/local-studio.md)
 - [How to connect to a local deployment (Docker)](../cloud/how-tos/test_local_deployment.md)
-- [How to test your graph in LangGraph Studio (MacOS only)](../cloud/how-tos/invoke_studio.md)
 - [How to interact with threads in LangGraph Studio](../cloud/how-tos/threads_studio.md)
 - [How to add nodes as dataset examples in LangGraph Studio](../cloud/how-tos/datasets_studio.md)
+- [How to engineer prompts in LangGraph Studio](../cloud/how-tos/iterate_graph_studio.md)
 
 ## Troubleshooting
 
@@ -305,4 +309,4 @@ These are the guides for resolving common errors you may find while building wit
 
 These guides provide troubleshooting information for errors that are specific to the LangGraph Platform.
 
-- [INVALID_LICENSE](../troubleshooting/errors/INVALID_LICENSE.md)
+- [INVALID_LICENSE](../troubleshooting/errors/INVALID_LICENSE.md)

docs/docs/how-tos/local-studio.md

@@ -1,15 +1,6 @@
 # How to connect a local agent to LangGraph Studio
 
-This guide shows you how to connect your local agent to [LangGraph Studio](../concepts/langgraph_studio.md) for visualization, interaction, and debugging.
-
-## Connection Options
-
-There are two ways to connect your local agent to LangGraph Studio:
-
-- [Development Server](../concepts/langgraph_studio.md#development-server-with-web-ui): Python package, all platforms, no Docker
-- [LangGraph Desktop](../concepts/langgraph_studio.md#desktop-app): Application, Mac only, requires Docker
-
-In this guide we will cover how to use the development server as that is generally an easier and better experience.
+This guide shows you how to connect your local agent to [LangGraph Studio](../concepts/langgraph_studio.md) for visualization, interaction, and debugging using the development server.
 
 ## Setup your application
 
@@ -24,9 +15,8 @@ You will need to make sure to install the `inmem` extras.
 
 ???+ note "Minimum version"
 
-  The minimum version to use the `inmem` extra with `langgraph-cli` is `0.1.55`.
-  Python 3.11 or higher is required.
-  
+The minimum version to use the `inmem` extra with `langgraph-cli` is `0.1.55`.
+Python 3.11 or higher is required.
 
 ```shell
 pip install -U "langgraph-cli[inmem]"
@@ -41,7 +31,7 @@ pip install -U "langgraph-cli[inmem]"
    langgraph dev
    ```
 
-This will look for the `langgraph.json` file in your current directory. 
+This will look for the `langgraph.json` file in your current directory.
 In there, it will find the paths to the graph(s), and start those up.
 It will then automatically connect to the cloud-hosted studio.
 
@@ -89,4 +79,4 @@ Then attach your preferred debugger:
     2. Click + and select "Python Debug Server"
     3. Set IDE host name: `localhost`
     4. Set port: `5678` (or the port number you chose in the previous step)
-    5. Click "OK" and start debugging
+    5. Click "OK" and start debugging

docs/docs/how-tos/map-reduce.ipynb

@@ -207,7 +207,7 @@
     "\n",
     "\n",
     "# Here we define the logic to map out over the generated subjects\n",
-    "# We will use this an edge in the graph\n",
+    "# We will use this as an edge in the graph\n",
     "def continue_to_jokes(state: OverallState):\n",
     "    # We will return a list of `Send` objects\n",
     "    # Each `Send` object consists of the name of a node in the graph\n",

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

@@ -10,6 +10,7 @@
     "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/llms.txt

@@ -0,0 +1,191 @@
+# 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/docs/reference/pregel.md

@@ -1,9 +1,7 @@
-::: langgraph.pregel.Pregel
+# Pregel
+
+::: langgraph.pregel
     options:
       members:
-        - stream
-        - astream
-        - invoke
-        - ainvoke
-        - update_state
-        - aupdate_state
+        - Pregel 
+        - PregelNode 

docs/docs/tutorials/workflows/index.md

@@ -184,7 +184,7 @@ As noted in the [Anthropic blog](https://www.anthropic.com/research/building-eff
 
     See our lesson on Prompt Chaining [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/chain.ipynb).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from langgraph.func import entrypoint, task
@@ -335,7 +335,7 @@ With parallelization, LLMs work simultaneously on a task:
 
     See our lesson on parallelization [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/simple-graph.ipynb).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     @task
@@ -524,7 +524,7 @@ Routing classifies an input and directs it to a followup task. As noted in the [
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is RAG workflow that routes questions. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from typing_extensions import Literal
@@ -761,7 +761,7 @@ With orchestrator-worker, an orchestrator breaks down a task and delegates each
     [Here](https://github.com/langchain-ai/report-mAIstro) is a project that uses orchestrator-worker for report planning and writing. See our video [here](https://www.youtube.com/watch?v=wSxZ7yFbbas).
 
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from typing import List
@@ -952,7 +952,7 @@ In the evaluator-optimizer workflow, one LLM call generates a response while ano
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is a RAG workflow that grades answers for hallucinations or errors. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     # Schema for structured output to use in evaluation
@@ -1161,7 +1161,7 @@ llm_with_tools = llm.bind_tools(tools)
 
     [Here](https://github.com/langchain-ai/memory-agent) is a project that uses a tool calling agent to create / store long-term memories.
 
-=== "Functional API (beta)"
+=== "Functional API"
 
     ```python
     from langgraph.graph import add_messages
@@ -1270,4 +1270,4 @@ LangGraph provides several ways to stream workflow / agent outputs or intermedia
 
 ### Deployment
 
-LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.
+LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.

docs/mkdocs.yml

@@ -271,6 +271,7 @@ nav:
           - concepts/streaming.md
           - concepts/functional_api.md
           - concepts/durable_execution.md
+          - concepts/pregel.md
         - LangGraph Platform:
           - LangGraph Platform: concepts#langgraph-platform
           - High Level:
@@ -358,7 +359,7 @@ nav:
     - Resources:
       # NOTE: prebuilt.md is auto-generated by `make build-prebuilt`
       - Prebuilt Agents: prebuilt.md
-      - Adopters: adopters.md
+      - Companies using LangGraph: adopters.md
       - FAQ: concepts/faq.md
       - Troubleshooting:
           - Troubleshooting: troubleshooting/errors/index.md

docs/poetry.lock

@@ -169,15 +169,15 @@ files = [
 
 [[package]]
 name = "anthropic"
-version = "0.45.2"
+version = "0.47.2"
 description = "The official Python library for the anthropic API"
 optional = false
 python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "anthropic-0.45.2-py3-none-any.whl", hash = "sha256:ecd746f7274451dfcb7e1180571ead624c7e1195d1d46cb7c70143d2aedb4d35"},
-    {file = "anthropic-0.45.2.tar.gz", hash = "sha256:32a18b9ecd12c91b2be4cae6ca2ab46a06937b5aa01b21308d97a6d29794fb5e"},
+    {file = "anthropic-0.47.2-py3-none-any.whl", hash = "sha256:61b712a56308fce69f04d92ba0230ab2bc187b5bce17811d400843a8976bb67f"},
+    {file = "anthropic-0.47.2.tar.gz", hash = "sha256:452f4ca0c56ffab8b6ce9928bf8470650f88106a7001b250895eb65c54cfa44c"},
 ]
 
 [package.dependencies]
@@ -1299,7 +1299,7 @@ version = "0.7.1"
 description = "XML bomb protection for Python stdlib modules"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-groups = ["docs", "test"]
+groups = ["docs"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"},
@@ -3288,21 +3288,20 @@ together = ["langchain-together"]
 
 [[package]]
 name = "langchain-anthropic"
-version = "0.2.4"
+version = "0.3.8"
 description = "An integration package connecting AnthropicMessages and LangChain"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_anthropic-0.2.4-py3-none-any.whl", hash = "sha256:bcb6c2d0df4a67aff52816621079d6e743b260911caccf313a72b33b7edece6f"},
-    {file = "langchain_anthropic-0.2.4.tar.gz", hash = "sha256:0382d4c7b5236839b703f7b72b3e06de4bb5be99104b193f719adbe34c49562b"},
+    {file = "langchain_anthropic-0.3.8-py3-none-any.whl", hash = "sha256:05a70f51500d3c4e0f3e463730e193a25b6244e06b3bda3d7b2ec21d83d081ae"},
+    {file = "langchain_anthropic-0.3.8.tar.gz", hash = "sha256:1932977b8105744739ffdcb39861b041b73ae93846d0896a775fcea9a29e4b2b"},
 ]
 
 [package.dependencies]
-anthropic = ">=0.30.0,<1"
-defusedxml = ">=0.7.1,<0.8.0"
-langchain-core = ">=0.3.15,<0.4.0"
+anthropic = ">=0.47.0,<1"
+langchain-core = ">=0.3.39,<1.0.0"
 pydantic = ">=2.7.4,<3.0.0"
 
 [[package]]
@@ -3357,15 +3356,15 @@ tenacity = ">=8.1.0,<8.4.0 || >8.4.0,<10"
 
 [[package]]
 name = "langchain-core"
-version = "0.3.34"
+version = "0.3.40"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["docs", "test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_core-0.3.34-py3-none-any.whl", hash = "sha256:a057ebeddd2158d3be14bde341b25640ddf958b6989bd6e47160396f5a8202ae"},
-    {file = "langchain_core-0.3.34.tar.gz", hash = "sha256:26504cf1e8e6c310adad907b890d4e3c147581cfa7434114f6dc1134fe4bc6d3"},
+    {file = "langchain_core-0.3.40-py3-none-any.whl", hash = "sha256:9f31358741f10a13db8531e8288b8a5ae91904018c5c2e6f739d6645a98fca03"},
+    {file = "langchain_core-0.3.40.tar.gz", hash = "sha256:893a238b38491967c804662c1ec7c3e6ebaf223d1125331249c3cf3862ff2746"},
 ]
 
 [package.dependencies]
@@ -3474,19 +3473,19 @@ ollama = ">=0.4.4,<1"
 
 [[package]]
 name = "langchain-openai"
-version = "0.3.4"
+version = "0.3.7"
 description = "An integration package connecting OpenAI and LangChain"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_openai-0.3.4-py3-none-any.whl", hash = "sha256:58d0c014620eb92f4f46ff9daf584c2a7794896b1379eb85ad7be8d9f3493b61"},
-    {file = "langchain_openai-0.3.4.tar.gz", hash = "sha256:c6645745a1d1bf19f21ea6fa473a746bd464053ff57ce563215e6165a0c4b9f1"},
+    {file = "langchain_openai-0.3.7-py3-none-any.whl", hash = "sha256:0aefc7bdf8e7398d41e09c4313cace816df6438f2aa93d34f79523487310f0da"},
+    {file = "langchain_openai-0.3.7.tar.gz", hash = "sha256:b8b51a3aaa1cc3bda060651ea41145f7728219e8a7150b5404fb1e8446de9cef"},
 ]
 
 [package.dependencies]
-langchain-core = ">=0.3.34,<1.0.0"
+langchain-core = ">=0.3.39,<1.0.0"
 openai = ">=1.58.1,<2.0.0"
 tiktoken = ">=0.7,<1"
 
@@ -3508,17 +3507,17 @@ langchain-core = ">=0.3.34,<1.0.0"
 
 [[package]]
 name = "langgraph"
-version = "0.2.71"
+version = "0.3.0"
 description = "Building stateful, multi-actor applications with LLMs"
 optional = false
 python-versions = ">=3.9.0,<4.0"
-groups = ["docs", "test"]
+groups = ["docs"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = []
 develop = true
 
 [package.dependencies]
-langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
+langchain-core = ">=0.1,<0.4"
 langgraph-checkpoint = "^2.0.10"
 langgraph-sdk = "^0.1.42"
 
@@ -3528,7 +3527,7 @@ url = "../libs/langgraph"
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "2.0.13"
+version = "2.0.16"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -3547,26 +3546,25 @@ url = "../libs/checkpoint"
 
 [[package]]
 name = "langgraph-checkpoint-mongodb"
-version = "0.1.0"
+version = "0.1.1"
 description = "Library with a MongoDB implementation of LangGraph checkpoint saver."
 optional = false
-python-versions = "<4.0.0,>=3.9.0"
+python-versions = ">=3.9"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langgraph_checkpoint_mongodb-0.1.0-py3-none-any.whl", hash = "sha256:52f20956b36e0275ff805a1eea1db4c1a7e5e0ffe0a1ade65969004fa1654703"},
-    {file = "langgraph_checkpoint_mongodb-0.1.0.tar.gz", hash = "sha256:3165c134ad5c82a3fe02fef04c81dcd48a3f5d031e07a9d1cb84457241f76793"},
+    {file = "langgraph_checkpoint_mongodb-0.1.1-py3-none-any.whl", hash = "sha256:1ff2c3cb2a9139c38ea9cf398659b8b32d6bbfcc4999713b62014431477c5ac5"},
+    {file = "langgraph_checkpoint_mongodb-0.1.1.tar.gz", hash = "sha256:350d347b0458fb7977231ac1295095bef512458ee0debe09fd394d913b8d89d3"},
 ]
 
 [package.dependencies]
-langgraph = ">=0.2.38,<0.3.0"
-langgraph-checkpoint = ">=2.0.0,<3.0.0"
+langgraph-checkpoint = ">=2.0.0"
 motor = ">3.5.0"
-pymongo = ">=4.9.0,<4.10.0"
+pymongo = ">=4.9,<4.12"
 
 [[package]]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.14"
+version = "2.0.15"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -3576,7 +3574,7 @@ files = []
 develop = true
 
 [package.dependencies]
-langgraph-checkpoint = "^2.0.10"
+langgraph-checkpoint = "^2.0.15"
 orjson = ">=3.10.1"
 psycopg = "^3.2.0"
 psycopg-pool = "^3.2.0"
@@ -3587,7 +3585,7 @@ url = "../libs/checkpoint-postgres"
 
 [[package]]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.4"
+version = "2.0.5"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0"
@@ -3597,20 +3595,40 @@ files = []
 develop = true
 
 [package.dependencies]
-aiosqlite = "^0.20.0"
-langgraph-checkpoint = "^2.0.10"
+aiosqlite = ">=0.20,<0.22"
+langgraph-checkpoint = "^2.0.15"
 
 [package.source]
 type = "directory"
 url = "../libs/checkpoint-sqlite"
 
+[[package]]
+name = "langgraph-prebuilt"
+version = "1.0.0"
+description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
+optional = false
+python-versions = "^3.9.0,<4.0"
+groups = ["docs"]
+markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
+files = []
+develop = true
+
+[package.dependencies]
+langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
+langgraph = ">=0.3,<0.4"
+langgraph-checkpoint = "^2.0.10"
+
+[package.source]
+type = "directory"
+url = "../libs/prebuilt"
+
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.51"
+version = "0.1.53"
 description = "SDK for interacting with LangGraph API"
 optional = false
 python-versions = "^3.9.0,<4.0"
-groups = ["docs", "test"]
+groups = ["docs"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = []
 develop = true
@@ -5939,7 +5957,6 @@ python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
     {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
 ]
 
@@ -5952,7 +5969,6 @@ python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"},
     {file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"},
 ]
 
@@ -8634,4 +8650,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.10"
-content-hash = "06debb82135affdb2baf1fdcc028c062c236121508d787588cd0de1db2da11e4"
+content-hash = "ac9af57c6abaddd1f181551a7bb8194ef3e4491391a0f2dc71417d68e85cb5b3"

docs/pyproject.toml

@@ -13,6 +13,7 @@ hub = "^3.0.1"
 
 [tool.poetry.group.docs.dependencies]
 langgraph = { path = "../libs/langgraph/", develop = true }
+langgraph-prebuilt = {path = "../libs/prebuilt", develop = true}
 langgraph-checkpoint = { path = "../libs/checkpoint/", develop = true }
 langgraph-checkpoint-sqlite = { path = "../libs/checkpoint-sqlite", develop = true }
 langgraph-checkpoint-postgres = { path = "../libs/checkpoint-postgres", develop = true }
@@ -40,8 +41,8 @@ langchain-cohere = "^0.4.2"
 
 [tool.poetry.group.test.dependencies]
 langchain = "^0.3.8"
-langchain-openai = "^0.3.0"
-langchain-anthropic = "^0.2.1"
+langchain-openai = "^0.3.7"
+langchain-anthropic = "^0.3.8"
 langchain-nomic = "^0.1.3"
 langchain-fireworks = "^0.2.0"
 langchain-community = "^0.3.0"

docs/tests/unit_tests/test_api_reference.py

@@ -0,0 +1,212 @@
+"""Test generation of links into the API reference."""
+
+import pytest
+
+from _scripts.generate_api_reference_links import (
+    update_markdown_with_imports,
+    get_imports,
+)
+
+MARKDOWN_IMPORTS = """\
+```python
+from langgraph.types import interrupt
+```
+"""
+
+EXPECTED_MARKDOWN = """\
+```python
+from langgraph.types import interrupt
+```
+
+API Reference: <a href="https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt">interrupt</a>
+"""
+
+
+def test_update_markdown_with_imports() -> None:
+    """Light weight end-to-end test."""
+    assert (
+        update_markdown_with_imports(MARKDOWN_IMPORTS, "some_path") == EXPECTED_MARKDOWN
+    )
+
+
+@pytest.mark.parametrize(
+    "code_block, expected_imports",
+    [
+        (
+            "from langgraph.types import interrupt",
+            [
+                {
+                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
+                    "imported": "interrupt",
+                    "path": "some_path",
+                    "source": "langgraph.types",
+                }
+            ],
+        ),
+        (
+            "from langgraph.types import ( interrupt )",
+            [
+                {
+                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
+                    "imported": "interrupt",
+                    "path": "some_path",
+                    "source": "langgraph.types",
+                }
+            ],
+        ),
+        (
+            "from langgraph.types import interrupt as foo",
+            [
+                {
+                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
+                    "imported": "interrupt",
+                    "path": "some_path",
+                    "source": "langgraph.types",
+                }
+            ],
+        ),
+    ],
+)
+def test_get_imports(code_block: str, expected_imports: list) -> None:
+    """Get imports from a code block."""
+    assert (
+        get_imports(code_block, "some_path") == expected_imports
+    ), f"Failed for code_block=`{code_block}`"
+
+
+@pytest.mark.parametrize(
+    "code, expected_imports",
+    [
+        # Single import without parenthesis
+        (
+            "from langgraph.types import interrupt",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                }
+            ],
+        ),
+        # Multiple imports
+        (
+            (
+                "from langgraph.types import interrupt\n"
+                "from langgraph.func import task"
+            ),
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                },
+                {
+                    "source": "langgraph.func",
+                    "imported": "task",
+                },
+            ],
+        ),
+        # Single import with parenthesis and extra whitespace
+        (
+            "from langgraph.types import ( interrupt )",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                }
+            ],
+        ),
+        # Single import with an alias
+        (
+            "from langgraph.types import interrupt as foo",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                }
+            ],
+        ),
+        # Multiple imports on one line with an alias
+        (
+            "from langgraph.types import interrupt, StreamWriter as bar",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "StreamWriter",
+                },
+            ],
+        ),
+        # Multiple imports without aliases
+        (
+            "from langgraph.types import interrupt, StreamWriter",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "StreamWriter",
+                },
+            ],
+        ),
+        # Multiline import with parenthesis and trailing comma
+        (
+            """from langgraph.types import (
+            interrupt,
+            StreamWriter as foo,
+            Command,
+        )""",
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "StreamWriter",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "Command",
+                },
+            ],
+        ),
+        # Multiline import with parenthesis and trailing comma
+        (
+            (
+                "from langgraph.types import (\n"
+                "        interrupt,\n"
+                "        StreamWriter as foo\n,"
+                "        Command,\n"
+                ")\n"
+                "def foo():\n"
+                "    pass\n"
+                ""
+            ),
+            [
+                {
+                    "source": "langgraph.types",
+                    "imported": "interrupt",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "StreamWriter",
+                },
+                {
+                    "source": "langgraph.types",
+                    "imported": "Command",
+                },
+            ],
+        ),
+    ],
+)
+def test_regexp_matching(code: str, expected_imports: list) -> None:
+    results = get_imports(code, "some_path")
+    for result in results:
+        del result["docs"]
+        del result["path"]
+
+    assert results == expected_imports

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

@@ -20,7 +20,7 @@ from langgraph.store.base import (
 )
 from langgraph.store.base.batch import AsyncBatchedBaseStore
 from langgraph.store.postgres.base import (
-    _PLACEHOLDER,
+    PLACEHOLDER,
     BasePostgresStore,
     PoolConfig,
     PostgresIndexConfig,
@@ -360,7 +360,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
             for (idx, _), vector in zip(embedding_requests, vectors):
                 _paramslist = queries[idx][1]
                 for i in range(len(_paramslist)):
-                    if _paramslist[i] is _PLACEHOLDER:
+                    if _paramslist[i] is PLACEHOLDER:
                         _paramslist[i] = vector
 
         for (idx, _), (query, params) in zip(search_ops, queries):

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

@@ -39,6 +39,7 @@ from langgraph.store.base import (
     Result,
     SearchItem,
     SearchOp,
+    TTLConfig,
     ensure_embeddings,
     get_text_at_path,
     tokenize_path,
@@ -370,7 +371,7 @@ class BasePostgresStore(Generic[C]):
             if op.query and self.index_config:
                 embedding_requests.append((idx, op.query))
 
-                score_operator, post_operator = _get_distance_operator(self)
+                score_operator, post_operator = get_distance_operator(self)
                 vector_type = (
                     cast(PostgresIndexConfig, self.index_config)
                     .get("ann_index_config", {})
@@ -430,10 +431,10 @@ class BasePostgresStore(Generic[C]):
                     OFFSET %s
                 """
                 params = [
-                    _PLACEHOLDER,  # Vector placeholder
+                    PLACEHOLDER,  # Vector placeholder
                     *ns_args,
                     *filter_params,
-                    _PLACEHOLDER,
+                    PLACEHOLDER,
                     expanded_limit,
                     op.limit,
                     op.offset,
@@ -622,6 +623,7 @@ 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
@@ -634,6 +636,7 @@ 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
 
     @classmethod
     @contextmanager
@@ -828,7 +831,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
             for (idx, _), embedding in zip(embedding_requests, embeddings):
                 _paramslist = queries[idx][1]
                 for i in range(len(_paramslist)):
-                    if _paramslist[i] is _PLACEHOLDER:
+                    if _paramslist[i] is PLACEHOLDER:
                         _paramslist[i] = embedding
 
         for (idx, _), (query, params) in zip(search_ops, queries):
@@ -1055,7 +1058,7 @@ def _decode_ns_bytes(namespace: Union[str, bytes, list]) -> tuple[str, ...]:
     return tuple(namespace.split("."))
 
 
-def _get_distance_operator(store: Any) -> tuple[str, str]:
+def get_distance_operator(store: Any) -> tuple[str, str]:
     """Get the distance operator and score expression based on config."""
     # Note: Today, we are not using ANN indices due to restrictions
     # on PGVector's support for mixing vector and non-vector filters
@@ -1121,4 +1124,4 @@ def _ensure_index_config(
     return embeddings, index_config
 
 
-_PLACEHOLDER = object()
+PLACEHOLDER = object()

libs/checkpoint-postgres/pyproject.toml

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

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

@@ -530,6 +530,7 @@ 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/poetry.lock

@@ -1,23 +1,23 @@
-# 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"
-version = "0.20.0"
+version = "0.21.0"
 description = "asyncio bridge to the standard sqlite3 module"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 groups = ["main"]
 files = [
-    {file = "aiosqlite-0.20.0-py3-none-any.whl", hash = "sha256:36a1deaca0cac40ebe32aac9977a6e2bbc7f5189f23f4a54d5908986729e5bd6"},
-    {file = "aiosqlite-0.20.0.tar.gz", hash = "sha256:6d35c8c256637f4672f843c31021464090805bf925385ac39473fb16eaaca3d7"},
+    {file = "aiosqlite-0.21.0-py3-none-any.whl", hash = "sha256:2549cf4057f95f53dcba16f2b64e8e2791d7e1adedb13197dd8ed77bb226d7d0"},
+    {file = "aiosqlite-0.21.0.tar.gz", hash = "sha256:131bb8056daa3bc875608c631c678cda73922a2d4ba8aec373b19f18c17e7aa3"},
 ]
 
 [package.dependencies]
 typing_extensions = ">=4.0"
 
 [package.extras]
-dev = ["attribution (==1.7.0)", "black (==24.2.0)", "coverage[toml] (==7.4.1)", "flake8 (==7.0.0)", "flake8-bugbear (==24.2.6)", "flit (==3.9.0)", "mypy (==1.8.0)", "ufmt (==2.3.0)", "usort (==1.0.8.post1)"]
-docs = ["sphinx (==7.2.6)", "sphinx-mdinclude (==0.5.3)"]
+dev = ["attribution (==1.7.1)", "black (==24.3.0)", "build (>=1.2)", "coverage[toml] (==7.6.10)", "flake8 (==7.0.0)", "flake8-bugbear (==24.12.12)", "flit (==3.10.1)", "mypy (==1.14.1)", "ufmt (==2.5.1)", "usort (==1.0.8.post1)"]
+docs = ["sphinx (==8.1.3)", "sphinx-mdinclude (==0.6.1)"]
 
 [[package]]
 name = "annotated-types"
@@ -1043,4 +1043,4 @@ watchmedo = ["PyYAML (>=3.10)"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.9.0"
-content-hash = "e6d3ca9bce723c05f4c5ae9dc4bee872f7581b7763680b34112f1d280f5a9b0a"
+content-hash = "21896b8d3d283d95bc3988aa93f06faf5c47dadc2a8822e5a35672b9cb054693"

libs/checkpoint-sqlite/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.5"
+version = "2.0.6"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 authors = []
 license = "MIT"
@@ -11,7 +11,7 @@ packages = [{ include = "langgraph" }]
 [tool.poetry.dependencies]
 python = "^3.9.0"
 langgraph-checkpoint = "^2.0.15"
-aiosqlite = "^0.20.0"
+aiosqlite = ">=0.20,<0.22"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"

libs/checkpoint/README.md

@@ -1,6 +1,6 @@
 # LangGraph Checkpoint
 
-This library defines the base interface for LangGraph checkpointers. Checkpointers provide persistence layer for LangGraph. They allow you to interact with and manage the graph's state. When you use a graph with a checkpointer, the checkpointer saves a _checkpoint_ of the graph state at every superstep, enabling several powerful capabilities like human-in-the-loop, "memory" between interactions and more.
+This library defines the base interface for LangGraph checkpointers. Checkpointers provide a persistence layer for LangGraph. They allow you to interact with and manage the graph's state. When you use a graph with a checkpointer, the checkpointer saves a _checkpoint_ of the graph state at every superstep, enabling several powerful capabilities like human-in-the-loop, "memory" between interactions and more.
 
 ## Key concepts
 
@@ -12,8 +12,8 @@ Checkpoint is a snapshot of the graph state at a given point in time. Checkpoint
 
 Threads enable the checkpointing of multiple different runs, making them essential for multi-tenant chat applications and other scenarios where maintaining separate states is necessary. A thread is a unique ID assigned to a series of checkpoints saved by a checkpointer. When using a checkpointer, you must specify a `thread_id` and optionally `checkpoint_id` when running the graph.
 
-- `thread_id` is simply the ID of a thread. This is always required
-- `checkpoint_id` can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick of a run of a graph from some point halfway through a thread.
+- `thread_id` is simply the ID of a thread. This is always required.
+- `checkpoint_id` can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick off a run of a graph from some point halfway through a thread.
 
 You must pass these when invoking the graph as part of the configurable part of the config, e.g.
 

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

@@ -487,7 +487,12 @@ def _msgpack_ext_hook(code: int, data: bytes) -> Any:
             except Exception:
                 return cls.construct(**tup[2])
         except Exception:
-            return
+            # for pydantic objects we can't find/reconstruct
+            # let's return the kwargs dict instead
+            try:
+                return tup[2]
+            except NameError:
+                return
     elif code == EXT_PYDANTIC_V2:
         try:
             tup = msgpack.unpackb(
@@ -500,7 +505,12 @@ def _msgpack_ext_hook(code: int, data: bytes) -> Any:
             except Exception:
                 return cls.model_construct(**tup[2])
         except Exception:
-            return
+            # for pydantic objects we can't find/reconstruct
+            # let's return the kwargs dict instead
+            try:
+                return tup[2]
+            except NameError:
+                return
 
 
 def _msgpack_enc(data: Any) -> bytes:

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

@@ -11,9 +11,19 @@ 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,
@@ -24,6 +34,20 @@ 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.
 
@@ -59,7 +83,7 @@ class Item:
             else created_at
         )
         self.updated_at = (
-            datetime.fromisoformat(cast(str, created_at))
+            datetime.fromisoformat(cast(str, updated_at))
             if isinstance(updated_at, str)
             else updated_at
         )
@@ -166,6 +190,13 @@ class GetOp(NamedTuple):
         "doc456"  # For a document
         ```
     """
+    refresh_ttl: bool = True
+    """Whether to refresh TTLs for the returned item.
+
+    If no TTL was specified for the original item(s),
+    or if TTL support is not enabled for your adapter,
+    this argument is ignored.
+    """
 
 
 class SearchOp(NamedTuple):
@@ -260,6 +291,13 @@ class SearchOp(NamedTuple):
         - "technical documentation about REST APIs"
         - "machine learning papers from 2023"
     """
+    refresh_ttl: bool = True
+    """Whether to refresh TTLs for the returned item.
+
+    If no TTL was specified for the original item(s),
+    or if TTL support is not enabled for your adapter,
+    this argument is ignored.
+    """
 
 
 # Type representing a namespace path that can include wildcards
@@ -463,6 +501,15 @@ class PutOp(NamedTuple):
         ]
         ```
     """
+    ttl: Optional[float] = None
+    """Controls the TTL (time-to-live) for the item in minutes.
+
+    If provided, and if the store you are using supports this feature, the item
+    will expire this many minutes after it was last accessed. The expiration timer
+    refreshes on both read operations (get/search) and write operations (put/update).
+    When the TTL expires, the item will be scheduled for deletion on a best-effort basis.
+    Defaults to None (no expiration).
+    """
 
 
 Op = Union[GetOp, SearchOp, PutOp, ListNamespacesOp]
@@ -473,6 +520,25 @@ 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).
+    """
+
+
 class IndexConfig(TypedDict, total=False):
     """Configuration for indexing documents for semantic search in the store.
 
@@ -612,8 +678,14 @@ class BaseStore(ABC):
         by providing an `index` configuration at creation time. Without this
         configuration, semantic search is disabled and any `index` arguments
         to storage operations will have no effect.
+
+        Similarly, TTL (time-to-live) support is disabled by default.
+        Subclasses must explicitly set `supports_ttl = True` to enable this feature.
     """
 
+    supports_ttl: bool = False
+    ttl_config: Optional[TTLConfig] = None
+
     __slots__ = ("__weakref__",)
 
     @abstractmethod
@@ -640,17 +712,28 @@ class BaseStore(ABC):
             The order of results matches the order of input operations.
         """
 
-    def get(self, namespace: tuple[str, ...], key: str) -> Optional[Item]:
+    def get(
+        self,
+        namespace: tuple[str, ...],
+        key: str,
+        *,
+        refresh_ttl: Optional[bool] = None,
+    ) -> Optional[Item]:
         """Retrieve a single item.
 
         Args:
             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, key)])[0]
+        return self.batch(
+            [GetOp(namespace, str(key), _ensure_refresh(self.ttl_config, refresh_ttl))]
+        )[0]
 
     def search(
         self,
@@ -661,6 +744,7 @@ class BaseStore(ABC):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
+        refresh_ttl: Optional[bool] = None,
     ) -> list[SearchItem]:
         """Search for items within a namespace prefix.
 
@@ -670,6 +754,8 @@ class BaseStore(ABC):
             filter: Key-value pairs to filter results.
             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 no TTL is specified, this argument is ignored.
 
         Returns:
             List of items matching the search criteria.
@@ -707,7 +793,18 @@ class BaseStore(ABC):
             Note: Natural language search support depends on your store implementation
             and requires proper embedding configuration.
         """
-        return self.batch([SearchOp(namespace_prefix, filter, limit, offset, query)])[0]
+        return self.batch(
+            [
+                SearchOp(
+                    namespace_prefix,
+                    filter,
+                    limit,
+                    offset,
+                    query,
+                    _ensure_refresh(self.ttl_config, refresh_ttl),
+                )
+            ]
+        )[0]
 
     def put(
         self,
@@ -715,6 +812,8 @@ class BaseStore(ABC):
         key: str,
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
+        *,
+        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
     ) -> None:
         """Store or update an item in the store.
 
@@ -735,12 +834,20 @@ class BaseStore(ABC):
                     - Nested fields: "metadata.title"
                     - Array access: "chapters[*].content" (each indexed separately)
                     - Specific indices: "authors[0].name"
+            ttl: Time to live in minutes. Support for this argument depends on your store adapter.
+                If specified, the item will expire after this many minutes from when it was last accessed.
+                None means no expiration. Expired runs will be deleted opportunistically.
+                By default, the expiration timer refreshes on both read operations (get/search)
+                and write operations (put/update), whenever the item is included in the operation.
 
         Note:
             Indexing support depends on your store implementation.
             If you do not initialize the store with indexing capabilities,
             the `index` parameter will be ignored.
 
+            Similarly, TTL support depends on the specific store implementation.
+            Some implementations may not support expiration of items.
+
         ???+ example "Examples"
             Store item. Indexing depends on how you configure the store.
             ```python
@@ -759,7 +866,22 @@ class BaseStore(ABC):
             ```
         """
         _validate_namespace(namespace)
-        self.batch([PutOp(namespace, key, value, index=index)])
+        if ttl not in (NOT_PROVIDED, 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),
+                )
+            ]
+        )
 
     def delete(self, namespace: tuple[str, ...], key: str) -> None:
         """Delete an item.
@@ -768,7 +890,7 @@ class BaseStore(ABC):
             namespace: Hierarchical path for the item.
             key: Unique identifier within the namespace.
         """
-        self.batch([PutOp(namespace, key, None)])
+        self.batch([PutOp(namespace, str(key), None, ttl=None)])
 
     def list_namespaces(
         self,
@@ -823,7 +945,13 @@ class BaseStore(ABC):
         )
         return self.batch([op])[0]
 
-    async def aget(self, namespace: tuple[str, ...], key: str) -> Optional[Item]:
+    async def aget(
+        self,
+        namespace: tuple[str, ...],
+        key: str,
+        *,
+        refresh_ttl: Optional[bool] = None,
+    ) -> Optional[Item]:
         """Asynchronously retrieve a single item.
 
         Args:
@@ -833,7 +961,17 @@ class BaseStore(ABC):
         Returns:
             The retrieved item or None if not found.
         """
-        return (await self.abatch([GetOp(namespace, key)]))[0]
+        return (
+            await self.abatch(
+                [
+                    GetOp(
+                        namespace,
+                        str(key),
+                        _ensure_refresh(self.ttl_config, refresh_ttl),
+                    )
+                ]
+            )
+        )[0]
 
     async def asearch(
         self,
@@ -844,6 +982,7 @@ class BaseStore(ABC):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
+        refresh_ttl: Optional[bool] = None,
     ) -> list[SearchItem]:
         """Asynchronously search for items within a namespace prefix.
 
@@ -853,6 +992,9 @@ class BaseStore(ABC):
             filter: Key-value pairs to filter results.
             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.
 
         Returns:
             List of items matching the search criteria.
@@ -892,7 +1034,16 @@ class BaseStore(ABC):
         """
         return (
             await self.abatch(
-                [SearchOp(namespace_prefix, filter, limit, offset, query)]
+                [
+                    SearchOp(
+                        namespace_prefix,
+                        filter,
+                        limit,
+                        offset,
+                        query,
+                        _ensure_refresh(self.ttl_config, refresh_ttl),
+                    )
+                ]
             )
         )[0]
 
@@ -902,6 +1053,8 @@ class BaseStore(ABC):
         key: str,
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
+        *,
+        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
     ) -> None:
         """Asynchronously store or update an item in the store.
 
@@ -922,12 +1075,20 @@ class BaseStore(ABC):
                     - Nested fields: "metadata.title"
                     - Array access: "chapters[*].content" (each indexed separately)
                     - Specific indices: "authors[0].name"
+            ttl: Time to live in minutes. Support for this argument depends on your store adapter.
+                If specified, the item will expire after this many minutes from when it was last accessed.
+                None means no expiration. Expired runs will be deleted opportunistically.
+                By default, the expiration timer refreshes on both read operations (get/search)
+                and write operations (put/update), whenever the item is included in the operation.
 
         Note:
             Indexing support depends on your store implementation.
             If you do not initialize the store with indexing capabilities,
             the `index` parameter will be ignored.
 
+            Similarly, TTL support depends on the specific store implementation.
+            Some implementations may not support expiration of items.
+
         ???+ example "Examples"
             Store item. Indexing depends on how you configure the store.
             ```python
@@ -954,7 +1115,22 @@ class BaseStore(ABC):
             ```
         """
         _validate_namespace(namespace)
-        await self.abatch([PutOp(namespace, key, value, index=index)])
+        if ttl not in (NOT_PROVIDED, 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),
+                )
+            ]
+        )
 
     async def adelete(self, namespace: tuple[str, ...], key: str) -> None:
         """Asynchronously delete an item.
@@ -963,7 +1139,7 @@ class BaseStore(ABC):
             namespace: Hierarchical path for the item.
             key: Unique identifier within the namespace.
         """
-        await self.abatch([PutOp(namespace, key, None)])
+        await self.abatch([PutOp(namespace, str(key), None)])
 
     async def alist_namespaces(
         self,
@@ -1043,6 +1219,27 @@ 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,17 +5,21 @@ 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,
 )
 
@@ -68,10 +72,21 @@ class AsyncBatchedBaseStore(BaseStore):
         self,
         namespace: tuple[str, ...],
         key: str,
+        *,
+        refresh_ttl: Optional[bool] = None,
     ) -> Optional[Item]:
         assert not self._task.done()
         fut = self._loop.create_future()
-        self._aqueue.put_nowait((fut, GetOp(namespace, key)))
+        self._aqueue.put_nowait(
+            (
+                fut,
+                GetOp(
+                    namespace,
+                    key,
+                    refresh_ttl=_ensure_refresh(self.ttl_config, refresh_ttl),
+                ),
+            )
+        )
         return await fut
 
     async def asearch(
@@ -83,11 +98,22 @@ class AsyncBatchedBaseStore(BaseStore):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
+        refresh_ttl: Optional[bool] = None,
     ) -> list[SearchItem]:
         assert not self._task.done()
         fut = self._loop.create_future()
         self._aqueue.put_nowait(
-            (fut, SearchOp(namespace_prefix, filter, limit, offset, query))
+            (
+                fut,
+                SearchOp(
+                    namespace_prefix,
+                    filter,
+                    limit,
+                    offset,
+                    query,
+                    refresh_ttl=_ensure_refresh(self.ttl_config, refresh_ttl),
+                ),
+            )
         )
         return await fut
 
@@ -97,11 +123,20 @@ class AsyncBatchedBaseStore(BaseStore):
         key: str,
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
+        *,
+        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
     ) -> None:
         assert not self._task.done()
         _validate_namespace(namespace)
         fut = self._loop.create_future()
-        self._aqueue.put_nowait((fut, PutOp(namespace, key, value, index)))
+        self._aqueue.put_nowait(
+            (
+                fut,
+                PutOp(
+                    namespace, key, value, index, ttl=_ensure_ttl(self.ttl_config, ttl)
+                ),
+            )
+        )
         return await fut
 
     async def adelete(
@@ -149,9 +184,11 @@ class AsyncBatchedBaseStore(BaseStore):
         self,
         namespace: tuple[str, ...],
         key: str,
+        *,
+        refresh_ttl: Optional[bool] = None,
     ) -> Optional[Item]:
         return asyncio.run_coroutine_threadsafe(
-            self.aget(namespace, key=key), self._loop
+            self.aget(namespace, key=key, refresh_ttl=refresh_ttl), self._loop
         ).result()
 
     @_check_loop
@@ -164,10 +201,16 @@ class AsyncBatchedBaseStore(BaseStore):
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
+        refresh_ttl: Optional[bool] = None,
     ) -> list[SearchItem]:
         return asyncio.run_coroutine_threadsafe(
             self.asearch(
-                namespace_prefix, query=query, filter=filter, limit=limit, offset=offset
+                namespace_prefix,
+                query=query,
+                filter=filter,
+                limit=limit,
+                offset=offset,
+                refresh_ttl=refresh_ttl,
             ),
             self._loop,
         ).result()
@@ -179,10 +222,19 @@ class AsyncBatchedBaseStore(BaseStore):
         key: str,
         value: dict[str, Any],
         index: Optional[Union[Literal[False], list[str]]] = None,
+        *,
+        ttl: Union[Optional[float], "NotProvided"] = NOT_PROVIDED,
     ) -> None:
         _validate_namespace(namespace)
         asyncio.run_coroutine_threadsafe(
-            self.aput(namespace, key=key, value=value, index=index), self._loop
+            self.aput(
+                namespace,
+                key=key,
+                value=value,
+                index=index,
+                ttl=_ensure_ttl(self.ttl_config, ttl),
+            ),
+            self._loop,
         ).result()
 
     @_check_loop

libs/checkpoint/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint"
-version = "2.0.16"
+version = "2.0.19"
 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, 10, 128397),
+            updated_at=datetime(2024, 9, 24, 17, 29, 11, 128397),
         ),
     }
 

libs/checkpoint/tests/test_store.py

@@ -148,8 +148,8 @@ async def test_async_batch_store(mocker: MockerFixture) -> None:
     assert abatch.call_count == 1
     assert [tuple(c.args[0]) for c in abatch.call_args_list] == [
         (
-            GetOp(("a",), "b"),
-            GetOp(("c",), "d"),
+            GetOp(("a",), "b", refresh_ttl=True),
+            GetOp(("c",), "d", refresh_ttl=True),
         ),
     ]
 
@@ -467,8 +467,8 @@ async def test_async_batch_store_deduplication(mocker: MockerFixture) -> None:
     assert len(abatch.call_args_list) == 1
     ops = list(abatch.call_args_list[0].args[1])
     assert len(ops) == 2
-    assert GetOp(("test",), "same") in ops
-    assert GetOp(("test",), "different") in ops
+    assert GetOp(("test",), "same", refresh_ttl=True) in ops
+    assert GetOp(("test",), "different", refresh_ttl=True) in ops
 
     abatch.reset_mock()
 

libs/cli/generate_schema.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Script to generate a JSON schema for the langgraph-cli Config class.
+
+This script creates a schema.json file that can be referenced in langgraph.json files
+to provide IDE autocompletion and validation.
+"""
+
+import inspect
+import json
+import textwrap
+from pathlib import Path
+
+import msgspec
+
+from langgraph_cli.config import (
+    AuthConfig,
+    Config,
+    CorsConfig,
+    HttpConfig,
+    IndexConfig,
+    SecurityConfig,
+    StoreConfig,
+)
+
+
+def add_descriptions_to_schema(schema, cls):
+    """Add docstring descriptions to the schema properties."""
+    if schema.get("description"):
+        schema["description"] = inspect.cleandoc(schema["description"])
+    elif class_doc := inspect.getdoc(cls):
+        schema["description"] = inspect.cleandoc(class_doc)
+    # Get attribute docstrings from the class
+    attr_docs = {}
+
+    # Also check class annotations for docstrings
+    source_lines = inspect.getsourcelines(cls)[0]
+    current_attr = None
+    docstring_lines = []
+
+    for line in source_lines:
+        line = line.strip()
+
+        # Check for attribute definition (TypedDict style)
+        if ":" in line and not line.startswith("#") and not line.startswith('"""'):
+            parts = line.split(":", 1)
+            if len(parts) == 2 and parts[0].strip().isidentifier():
+                # If we were collecting a docstring, save it for the previous attribute
+                if current_attr and docstring_lines:
+                    attr_docs[current_attr] = "\n".join(docstring_lines).strip('"')
+                    docstring_lines = []
+
+                current_attr = parts[0].strip()
+
+        # Check for docstring after attribute
+        elif line.startswith('"""') and current_attr:
+            # Start or end of a docstring
+            if len(line) > 3 and line.endswith('"""'):
+                # Single line docstring
+                attr_docs[current_attr] = line.strip('"')
+                current_attr = None
+            elif docstring_lines:
+                # End of multi-line docstring
+                docstring_lines.append(line.rstrip('"'))
+                attr_docs[current_attr] = "\n".join(docstring_lines).strip('"')
+                docstring_lines = []
+                current_attr = None
+            else:
+                # Start of multi-line docstring
+                docstring_lines.append(line.lstrip('"'))
+
+        # Continue multi-line docstring
+        elif docstring_lines and current_attr:
+            docstring_lines.append(line.strip('"'))
+
+    # Add the last docstring if there is one
+    if current_attr and docstring_lines:
+        attr_docs[current_attr] = "\n".join(docstring_lines).strip('"')
+
+    # Add descriptions to properties
+    if "properties" in schema:
+        for prop_name, prop_schema in schema["properties"].items():
+            # First try to get from attribute docstrings
+            if prop_name in attr_docs and "description" not in prop_schema:
+                prop_schema["description"] = textwrap.dedent(attr_docs[prop_name])
+            # Fall back to class docstring parsing
+            elif class_doc:
+                for line in class_doc.split("\n"):
+                    if line.strip().startswith(
+                        f"{prop_name}:"
+                    ) or line.strip().startswith(f'"{prop_name}"'):
+                        description = line.split(":", 1)[1].strip()
+                        if description and "description" not in prop_schema:
+                            prop_schema["description"] = description
+                            break
+
+    # Recursively process nested definitions
+    if "$defs" in schema:
+        for def_name, def_schema in schema["$defs"].items():
+            # Find the class that corresponds to this definition
+            for potential_cls in [
+                Config,
+                StoreConfig,
+                IndexConfig,
+                AuthConfig,
+                SecurityConfig,
+                HttpConfig,
+                CorsConfig,
+            ]:
+                if potential_cls.__name__ == def_name:
+                    add_descriptions_to_schema(def_schema, potential_cls)
+                    break
+
+    return schema
+
+
+def generate_schema():
+    """Generate a JSON schema for the Config class using msgspec."""
+    # Generate the basic schema
+    schema = msgspec.json.schema(Config)
+
+    # Add title and description
+    schema["title"] = "LangGraph CLI Configuration"
+    schema["description"] = "Configuration schema for langgraph-cli"
+
+    # Add docstring descriptions
+    schema = add_descriptions_to_schema(schema, Config)
+
+    # Add constraint that only one of python_version or node_version should be specified
+    config_schema = schema["$defs"]["Config"]
+
+    # Create two subschemas: one with python_version and one with node_version
+    # Define properties specific to Python projects
+    python_specific_props = ["python_version", "pip_config_file"]
+    # Define properties specific to Node.js projects
+    node_specific_props = ["node_version"]
+    # Define properties common to both project types
+    common_props = [
+        k
+        for k in config_schema["properties"]
+        if k not in python_specific_props and k not in node_specific_props
+    ]
+
+    # Create Python schema with python_version and pip_config_file
+    python_schema = {
+        "type": "object",
+        "properties": {
+            # Include Python-specific properties
+            **{k: config_schema["properties"][k].copy() for k in python_specific_props},
+            # Include common properties
+            **{k: config_schema["properties"][k].copy() for k in common_props},
+        },
+        "required": ["dependencies", "graphs"],
+    }
+
+    # Add enum constraint for python_version
+    if "python_version" in python_schema["properties"]:
+        python_schema["properties"]["python_version"]["enum"] = ["3.11", "3.12"]
+
+    # Create Node.js schema with node_version
+    node_schema = {
+        "type": "object",
+        "properties": {
+            # Include Node-specific properties
+            **{k: config_schema["properties"][k].copy() for k in node_specific_props},
+            # Include common properties
+            **{k: config_schema["properties"][k].copy() for k in common_props},
+        },
+        "required": ["node_version", "graphs"],
+    }
+
+    # Add enum constraint for node_version
+    if "node_version" in node_schema["properties"]:
+        node_schema["properties"]["node_version"]["anyOf"] = [
+            {"type": "string", "enum": ["20"]},
+            {"type": "null"},
+        ]
+
+    # Replace the Config schema with a oneOf constraint
+    config_schema["oneOf"] = [python_schema, node_schema]
+
+    # Remove the properties field as it's now defined in the oneOf subschemas
+    if "properties" in config_schema:
+        del config_schema["properties"]
+
+    return schema
+
+
+def main():
+    """Generate the schema and write it to a file."""
+    schema = generate_schema()
+
+    # Add versioning to the schema
+    import importlib.metadata
+
+    try:
+        version = importlib.metadata.version("langgraph_cli").split(".")
+        schema_version = f"v{version[0]}"
+    except importlib.metadata.PackageNotFoundError:
+        schema_version = "v1"
+
+    # Add version to schema
+    schema["version"] = schema_version
+
+    config_dir = Path(__file__).parent / "schemas"
+
+    # Create versioned schema file
+    versioned_path = config_dir / f"schema.{schema_version}.json"
+    with open(versioned_path, "w") as f:
+        json.dump(schema, f, indent=2)
+
+    # Also create a latest version
+    latest_path = config_dir / "schema.json"
+    with open(latest_path, "w") as f:
+        json.dump(schema, f, indent=2)
+
+    print(f"Schema written to {versioned_path} and {latest_path}")
+    print(
+        f"You can now add '$schema: https://raw.githubusercontent.com/langchain-ai/langgraph/refs/heads/main/libs/cli/schemas/schema.json'"
+        f" or '$schema: https://raw.githubusercontent.com/langchain-ai/langgraph/refs/heads/main/libs/cli/schemas/schema.{schema_version}.json'"
+        " to your langgraph.json files"
+    )
+
+
+if __name__ == "__main__":
+    main()

libs/cli/langgraph_cli/config.py

@@ -3,7 +3,7 @@ import os
 import pathlib
 import textwrap
 from collections import Counter
-from typing import NamedTuple, Optional, TypedDict, Union
+from typing import Any, NamedTuple, Optional, TypedDict, Union
 
 import click
 
@@ -11,13 +11,37 @@ 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.
+    """
+
+
 class IndexConfig(TypedDict, total=False):
-    """Configuration for indexing documents for semantic search in the store."""
+    """Configuration for indexing documents for semantic search in the store.
+
+    This governs how text is converted into embeddings and stored for vector-based lookups.
+    """
 
     dims: int
-    """Number of dimensions in the embedding vectors.
+    """Required. Dimensionality of the embedding vectors you will store.
     
-    Common embedding models have the following dimensions:
+    Must match the output dimension of your selected embedding model or custom embed function.
+    If mismatched, you will likely encounter shape/size errors when inserting or querying vectors.
+    
+    Common embedding model output dimensions:
         - openai:text-embedding-3-large: 3072
         - openai:text-embedding-3-small: 1536
         - openai:text-embedding-ada-002: 1536
@@ -28,42 +52,130 @@ class IndexConfig(TypedDict, total=False):
     """
 
     embed: str
-    """Optional model (string) to generate embeddings from text or path to model or function.
+    """Required. Identifier or reference to the embedding model or a custom embedding function.
     
-    Examples:
+    The format can vary:
+      - "<provider>:<model_name>" for recognized providers (e.g., "openai:text-embedding-3-large")
+      - "path/to/module.py:function_name" for your own local embedding function
+      - "my_custom_embed" if it's a known alias in your system
+
+     Examples:
         - "openai:text-embedding-3-large"
         - "cohere:embed-multilingual-v3.0"
-        - "src/app.py:embeddings
+        - "src/app.py:embeddings"
+    
+    Note: Must return embeddings of dimension `dims`.
     """
 
     fields: Optional[list[str]]
-    """Fields to extract text from for embedding generation.
+    """Optional. List of JSON fields to extract before generating embeddings.
     
-    Defaults to the root ["$"], which embeds the json object as a whole.
+    Defaults to ["$"], which means the entire JSON object is embedded as one piece of text.
+    If you provide multiple fields (e.g. ["title", "content"]), each is extracted and embedded separately,
+    often saving token usage if you only care about certain parts of the data.
+    
+    Example:
+        fields=["title", "abstract", "author.biography"]
     """
 
 
 class StoreConfig(TypedDict, total=False):
-    embed: Optional[IndexConfig]
-    """Configuration for vector embeddings in store."""
+    """Configuration for the built-in long-term memory store.
+
+    This store can optionally perform semantic search. If you omit `index`,
+    the store will just handle traditional (non-embedded) data without vector lookups.
+    """
+
+    index: Optional[IndexConfig]
+    """Optional. Defines the vector-based semantic search configuration.
+    
+    If provided, the store will:
+      - Generate embeddings according to `index.embed`
+      - Enforce the embedding dimension given by `index.dims`
+      - Embed only specified JSON fields (if any) from `index.fields`
+    
+    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):
-    securitySchemes: dict
-    security: list
+    """Configuration for OpenAPI security definitions and requirements.
+
+    Useful for specifying global or path-level authentication and authorization flows
+    (e.g., OAuth2, API key headers, etc.).
+    """
+
+    securitySchemes: dict[str, dict[str, Any]]
+    """Required. Dict describing each security scheme recognized by your OpenAPI spec.
+    
+    Keys are scheme names (e.g. "OAuth2", "ApiKeyAuth") and values are their definitions.
+    Example:
+        {
+            "OAuth2": {
+                "type": "oauth2",
+                "flows": {
+                    "password": {
+                        "tokenUrl": "/token",
+                        "scopes": {"read": "Read data", "write": "Write data"}
+                    }
+                }
+            }
+        }
+    """
+    security: list[dict[str, list[str]]]
+    """Optional. Global security requirements across all endpoints.
+    
+    Each element in the list maps a security scheme (e.g. "OAuth2") to a list of scopes (e.g. ["read", "write"]).
+    Example:
+        [
+            {"OAuth2": ["read", "write"]},
+            {"ApiKeyAuth": []}
+        ]
+    """
     # path => {method => security}
-    paths: dict[str, dict[str, list]]
+    paths: dict[str, dict[str, list[dict[str, list[str]]]]]
+    """Optional. Path-specific security overrides.
+    
+    Keys are path templates (e.g., "/items/{item_id}"), mapping to:
+      - Keys that are HTTP methods (e.g., "GET", "POST"),
+      - Values are lists of security definitions (just like `security`) for that method.
+    
+    Example:
+        {
+            "/private_data": {
+                "GET": [{"OAuth2": ["read"]}],
+                "POST": [{"OAuth2": ["write"]}]
+            }
+        }
+    """
 
 
 class AuthConfig(TypedDict, total=False):
-    path: str
-    """Path to the authentication function in a Python file."""
-    disable_studio_auth: bool
-    """Whether to disable auth when connecting from the LangSmith Studio."""
-    openapi: SecurityConfig
-    """The schema to use for updating the openapi spec.
+    """Configuration for custom authentication logic and how it integrates into the OpenAPI spec."""
 
-    Example:
+    path: str
+    """Required. Path to an instance of the Auth() class that implements custom authentication.
+    
+    Format: "path/to/file.py:my_auth"
+    """
+    disable_studio_auth: bool
+    """Optional. Whether to disable LangSmith API-key authentication for requests originating the Studio. 
+    
+    Defaults to False, meaning that if a particular header is set, the server will verify the `x-api-key` header
+    value is a valid API key for the deployment's workspace. If True, all requests will go through your custom
+    authentication logic, regardless of origin of the request.
+    """
+    openapi: SecurityConfig
+    """Required. Detailed security configuration that merges into your deployment's OpenAPI spec.
+    
+    Example (OAuth2):
         {
             "securitySchemes": {
                 "OAuth2": {
@@ -71,88 +183,185 @@ class AuthConfig(TypedDict, total=False):
                     "flows": {
                         "password": {
                             "tokenUrl": "/token",
-                            "scopes": {
-                                "me": "Read information about the current user",
-                                "items": "Access to create and manage items"
-                            }
+                            "scopes": {"me": "Read user info", "items": "Manage items"}
                         }
                     }
                 }
             },
             "security": [
-                {"OAuth2": ["me"]}  # Default security requirement for all endpoints
+                {"OAuth2": ["me"]}
             ]
         }
     """
 
 
 class CorsConfig(TypedDict, total=False):
+    """Specifies Cross-Origin Resource Sharing (CORS) rules for your server.
+
+    If omitted, defaults are typically very restrictive (often no cross-origin requests).
+    Configure carefully if you want to allow usage from browsers hosted on other domains.
+    """
+
     allow_origins: list[str]
+    """Optional. List of allowed origins (e.g., "https://example.com").
+    
+    Default is often an empty list (no external origins). 
+    Use "*" only if you trust all origins, as that bypasses most restrictions.
+    """
     allow_methods: list[str]
+    """Optional. HTTP methods permitted for cross-origin requests (e.g. ["GET", "POST"]).
+    
+    Default might be ["GET", "POST", "OPTIONS"] depending on your server framework.
+    """
     allow_headers: list[str]
+    """Optional. HTTP headers that can be used in cross-origin requests (e.g. ["Content-Type", "Authorization"])."""
     allow_credentials: bool
+    """Optional. If True, cross-origin requests can include credentials (cookies, auth headers).
+    
+    Default False to avoid accidentally exposing secured endpoints to untrusted sites.
+    """
     allow_origin_regex: str
+    """Optional. A regex pattern for matching allowed origins, used if you have dynamic subdomains.
+    
+    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."""
     max_age: int
+    """Optional. How many seconds the browser may cache preflight responses.
+    
+    Default might be 600 (10 minutes). Larger values reduce preflight requests but can cause stale configurations.
+    """
 
 
 class HttpConfig(TypedDict, total=False):
+    """Configuration for the built-in HTTP server that powers your deployment's routes and endpoints."""
+
     app: str
-    """Import path for a custom Starlette/FastAPI app to mount"""
+    """Optional. Import path to a custom Starlette/FastAPI application to mount.
+    
+    Format: "path/to/module.py:app_var"
+    If provided, it can override or extend the default routes.
+    """
     disable_assistants: bool
-    """Disable /assistants routes"""
+    """Optional. If True, /assistants routes are removed from the server.
+    
+    Default is False (meaning /assistants is enabled).
+    """
     disable_threads: bool
-    """Disable /threads routes"""
+    """Optional. If True, /threads routes are removed.
+    
+    Default is False.
+    """
     disable_runs: bool
-    """Disable /runs routes"""
+    """Optional. If True, /runs routes are removed.
+    
+    Default is False.
+    """
     disable_store: bool
-    """Disable /store routes"""
+    """Optional. If True, /store routes are removed, disabling direct store interactions via HTTP.
+    
+    Default is False.
+    """
     disable_meta: bool
-    """Disable /ok, /info, /metrics, and /docs routes"""
+    """Optional. If True, all meta endpoints (/ok, /info, /metrics, /docs) are disabled.
+    
+    Default is False.
+    """
     cors: Optional[CorsConfig]
-    """Cross-Origin Resource Sharing (CORS) configuration"""
+    """Optional. Defines CORS restrictions. If omitted, no special rules are set and 
+    cross-origin behavior depends on default server settings.
+    """
 
 
 class Config(TypedDict, total=False):
-    """Configuration for langgraph-cli."""
+    """Top-level config for langgraph-cli or similar deployment tooling."""
 
     python_version: str
-    """Python version to use."""
+    """Optional. Python version in 'major.minor' format (e.g. '3.11'). 
+    Must be at least 3.11 or greater for this deployment to function properly.
+    """
 
     node_version: Optional[str]
-    """Node.js version to use."""
+    """Optional. Node.js version as a major version (e.g. '20'), if your deployment needs Node.
+    Must be >= 20 if provided.
+    """
 
     pip_config_file: Optional[str]
-    """Path to a pip configuration file."""
+    """Optional. Path to a pip config file (e.g., "/etc/pip.conf" or "pip.ini") for controlling
+    package installation (custom indices, credentials, etc.).
+    
+    Only relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.
+    """
 
     dockerfile_lines: list[str]
-    """Additional lines to add to the Dockerfile."""
+    """Optional. Additional Docker instructions that will be appended to your base Dockerfile.
+    
+    Useful for installing OS packages, setting environment variables, etc. 
+    Example:
+        dockerfile_lines=[
+            "RUN apt-get update && apt-get install -y libmagic-dev",
+            "ENV MY_CUSTOM_VAR=hello_world"
+        ]
+    """
 
     dependencies: list[str]
-    """Additional Python dependencies to install."""
+    """List of Python dependencies to install, either from PyPI or local paths.
+    
+    Examples:
+      - "." or "./src" if you have a local Python package
+      - str (aka "anthropic") for a PyPI package
+      - "git+https://github.com/org/repo.git@main" for a Git-based package
+    Defaults to an empty list, meaning no additional packages installed beyond your base environment.
+    """
 
     graphs: dict[str, str]
-    """Mapping of graph names to their definitions."""
+    """Optional. Named definitions of graphs, each pointing to a Python object.
+
+    
+    Graphs can be StateGraph, @entrypoint, or any other Pregel object OR they can point to (async) context
+    managers that accept a single configuration argument (of type RunnableConfig) and return a pregel object
+    (instance of Stategraph, etc.).
+    
+    Keys are graph names, values are "path/to/file.py:object_name".
+    Example:
+        {
+            "mygraph": "graphs/my_graph.py:graph_definition",
+            "anothergraph": "graphs/another.py:get_graph"
+        }
+    """
 
     env: Union[dict[str, str], str]
-    """Environment variables to set.
-
-    If a dictionary is provided, the keys are environment variable names
-    and the values are the corresponding environment variable values.
-
-    If a string is provided, it is interpreted as a path to a file containing
-    environment variables in the format KEY=VALUE, with one environment variable
-    per line.
+    """Optional. Environment variables to set for your deployment.
+    
+    - If given as a dict, keys are variable names and values are their values.
+    - If given as a string, it must be a path to a file containing lines in KEY=VALUE format.
+    
+    Example as a dict:
+        env={"API_TOKEN": "abc123", "DEBUG": "true"}
+    Example as a file path:
+        env=".env"
     """
 
     store: Optional[StoreConfig]
-    """Configuration for vector embeddings in store."""
+    """Optional. Configuration for the built-in long-term memory store, including semantic search indexing.
+    
+    If omitted, no vector index is set up (the object store will still be present, however).
+    """
 
     auth: Optional[AuthConfig]
-    """Configuration for authentication."""
+    """Optional. Custom authentication config, including the path to your Python auth logic and 
+    the OpenAPI security definitions it uses.
+    """
 
     http: Optional[HttpConfig]
-    """Configuration for HTTP server."""
+    """Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed
+    and how cross-origin requests are handled.
+    """
+
+    ui: Optional[dict[str, str]]
+    """Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file.
+    """
 
 
 def _parse_version(version_str: str) -> tuple[int, int]:
@@ -189,6 +398,7 @@ def validate_config(config: Config) -> Config:
             "store": config.get("store"),
             "auth": config.get("auth"),
             "http": config.get("http"),
+            "ui": config.get("ui"),
         }
         if config.get("node_version")
         else {
@@ -201,6 +411,7 @@ def validate_config(config: Config) -> Config:
             "store": config.get("store"),
             "auth": config.get("auth"),
             "http": config.get("http"),
+            "ui": config.get("ui"),
         }
     )
 
@@ -687,9 +898,11 @@ def python_config_to_docker(
     pip_pkgs_str = f"RUN {pip_install} {' '.join(pypi_deps)}" if pypi_deps else ""
     if local_deps.pip_reqs:
         pip_reqs_str = os.linesep.join(
-            f"COPY --from=__outer_{reqpath.name} requirements.txt {destpath}"
-            if reqpath.parent in local_deps.additional_contexts
-            else f"ADD {reqpath.relative_to(config_path.parent)} {destpath}"
+            (
+                f"COPY --from=__outer_{reqpath.name} requirements.txt {destpath}"
+                if reqpath.parent in local_deps.additional_contexts
+                else f"ADD {reqpath.relative_to(config_path.parent)} {destpath}"
+            )
             for reqpath, destpath in local_deps.pip_reqs
         )
         pip_reqs_str += f'{os.linesep}RUN {pip_install} {" ".join("-r " + r for _,r in local_deps.pip_reqs)}'
@@ -724,13 +937,15 @@ RUN set -ex && \\
     )
 
     local_pkgs_str = os.linesep.join(
-        f"""# -- Adding local package {relpath} --
+        (
+            f"""# -- Adding local package {relpath} --
 COPY --from={name} . /deps/{name}
 # -- End of local package {relpath} --"""
-        if fullpath in local_deps.additional_contexts
-        else f"""# -- Adding local package {relpath} --
+            if fullpath in local_deps.additional_contexts
+            else f"""# -- Adding local package {relpath} --
 ADD {relpath} /deps/{name}
 # -- End of local package {relpath} --"""
+        )
         for fullpath, (relpath, name) in local_deps.real_pkgs.items()
     )
 
@@ -845,6 +1060,7 @@ ADD . {faux_path}
 RUN cd {faux_path} && {install_cmd}
 {env_additional_config}
 ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
+{f"ENV LANGGRAPH_UI='{json.dumps(config['ui'])}'" if config.get("ui") else ""}
 
 WORKDIR {faux_path}
 

libs/cli/poetry.lock

@@ -446,54 +446,47 @@ files = [
 
 [[package]]
 name = "jsonschema-rs"
-version = "0.25.1"
+version = "0.20.0"
 description = "A high-performance JSON Schema validator for Python"
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "jsonschema_rs-0.25.1-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0dc49a465a02f97a8c747e852bc82322dd56ff7d66b3058c9656e15b8a5e381c"},
-    {file = "jsonschema_rs-0.25.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:cf196d06dea3af58a23e6a03e363140ee307fc80fc77d8c71068df3de1bca588"},
-    {file = "jsonschema_rs-0.25.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f7bc2cac3891b75c301090effba458b6e7108d568aa2aeadb5695d7788991fa3"},
-    {file = "jsonschema_rs-0.25.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3bc130df50b530c57524c7edc29808700d51304f94477833fb0062e0f3df1dfb"},
-    {file = "jsonschema_rs-0.25.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dace81a4652029493a19e24454bb5f821acdacf65da4f6472bbdc6751c45b79"},
-    {file = "jsonschema_rs-0.25.1-cp310-none-win32.whl", hash = "sha256:dc9771bbe5672f89a974b7302f5e4421559a8d0903eab2c38510dd61bd526086"},
-    {file = "jsonschema_rs-0.25.1-cp310-none-win_amd64.whl", hash = "sha256:7be237cc251c0fe9fe196adf4a7a8402339bbf58ef8710ab76b9e4b845fc94bd"},
-    {file = "jsonschema_rs-0.25.1-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:df22e50adba344efc018322305386357bf30c4b6a9b48349f565ff410d1eb78e"},
-    {file = "jsonschema_rs-0.25.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:db9fb2086a8a64e40e95e0f6bb0a91ea387419d0d239fc59d468586702286a89"},
-    {file = "jsonschema_rs-0.25.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a168559e9f1fff42d9a2a78c46143fda7ee58a90b85a7d11140dfe16e609e92b"},
-    {file = "jsonschema_rs-0.25.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e4f659487071009749077b4f5ee69300772fa321f92fa831e71fd4218839958"},
-    {file = "jsonschema_rs-0.25.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b1e9f7c05c8c9656bb98ecc93a0b91408a6e73063956dea7452cd64277f3b9f"},
-    {file = "jsonschema_rs-0.25.1-cp311-none-win32.whl", hash = "sha256:406a18dafac01b7799dd86b1b05bf14e8628d1f8bc0a1a9c187458f246c2f6cc"},
-    {file = "jsonschema_rs-0.25.1-cp311-none-win_amd64.whl", hash = "sha256:3546274ae6e11fcc1b058cdd763803c4db24e49bac125076bc4fab0ab61d4786"},
-    {file = "jsonschema_rs-0.25.1-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:cfaed89ef79cc972d11c50889fa02e8265aa5b6b6826c40749b956888712909d"},
-    {file = "jsonschema_rs-0.25.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:87432343bcbd91475af28c765caa0bbde534bbfb6fac1245735a5a1dd6b522a4"},
-    {file = "jsonschema_rs-0.25.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e69c9faed321b7cfbeb37e98e385a0392ad8d25896fd3def56afd080e56e294c"},
-    {file = "jsonschema_rs-0.25.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f004018ffb7fbffc8f1dbeb1bda44f322c924e007bb6966ab3466bdffbc06e62"},
-    {file = "jsonschema_rs-0.25.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b05e2f6bf86ced9d912d72329a19d39a86fcc49a85e31b923456d982733eaa7f"},
-    {file = "jsonschema_rs-0.25.1-cp312-none-win32.whl", hash = "sha256:b3d2ea6217e3618ba587d374b89f4660de59293b0a2fa43278131bc2cb339f57"},
-    {file = "jsonschema_rs-0.25.1-cp312-none-win_amd64.whl", hash = "sha256:6ceeaec97e77d14d6355aec9e55b2356d6376fdf94f6fed10c29cadc8e51fdf6"},
-    {file = "jsonschema_rs-0.25.1-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:4696a580f54855cda68c05bbd7c25328eadca34b6a31b36495961235c511148d"},
-    {file = "jsonschema_rs-0.25.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:a2d9844d70e5a481a1c363b8b02a3862cc1dbc3b14551a8060436e53243d5447"},
-    {file = "jsonschema_rs-0.25.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fd168893519bae7c09fb7226f4ac4b6e73bc1ce9397c3846870cf980135762e8"},
-    {file = "jsonschema_rs-0.25.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e6627f4ecf1cb12765734f39a536bb4a062e35c9db756d52581b4d045489025"},
-    {file = "jsonschema_rs-0.25.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4784b0c1a0596595e0ea482d6656ccd33d7f14fbf32456e76fead0a67c6a7ec5"},
-    {file = "jsonschema_rs-0.25.1-cp313-none-win32.whl", hash = "sha256:7e6984721dbaaffc6a32ba15b4988df56e4069c9f867370a8a3c48a69a311ac3"},
-    {file = "jsonschema_rs-0.25.1-cp313-none-win_amd64.whl", hash = "sha256:62234e768a1cc57690602711e37f2b936b0f081dcd34a9c2b3e20ba0dafcbceb"},
-    {file = "jsonschema_rs-0.25.1-cp38-cp38-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:346a46f25d974b4ae1d36ac3c02677a699b46404b019a688ddabef40840019fc"},
-    {file = "jsonschema_rs-0.25.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:32f4908bc5c958a0a94a25260f5be59fba0062a60a40b61f0faedf12eed82063"},
-    {file = "jsonschema_rs-0.25.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ce090f2038f1a01836adf9f821f7e8c82073710c7a55b002a2e7a1625c3f3954"},
-    {file = "jsonschema_rs-0.25.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4ef0f3b0760ab151c35f5c8e090cdb201fb81eae2cf5ea1771f4d827d0cfbb1"},
-    {file = "jsonschema_rs-0.25.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c732bd71da96d6600ae550401e7997fb470f73f95af8defefe4fcbc5e4e9043"},
-    {file = "jsonschema_rs-0.25.1-cp38-none-win32.whl", hash = "sha256:b9ea15dfa5c47b1658e77c3a04e7c38b66e6a617617e1b9f5dba53b67712da1e"},
-    {file = "jsonschema_rs-0.25.1-cp38-none-win_amd64.whl", hash = "sha256:0d8438bea4c09994973ac60c645f4735808329908f4b9421f07d7f2ddf8ac860"},
-    {file = "jsonschema_rs-0.25.1-cp39-cp39-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:6c9ea0b69fab4a27e0c8c0edbee24db2da44d2a97657469ee30a2b980b0b445c"},
-    {file = "jsonschema_rs-0.25.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:9de3946a1cd66daae805578ad5cbf21ff4d590d7206048f0eb2999aab056a78a"},
-    {file = "jsonschema_rs-0.25.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3bd2ae54066e840cb5595d135b40c9458a0155e482998e00e922ea6b5ab57a24"},
-    {file = "jsonschema_rs-0.25.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb7e2a6777e78a699d09e5c6e84318e97a8e80727939fcde3d0faff7f9da85f3"},
-    {file = "jsonschema_rs-0.25.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a87babb64a93bad6bfbf2ddad0e33cab6c3f395e9572fe027387c7767e9741c"},
-    {file = "jsonschema_rs-0.25.1-cp39-none-win32.whl", hash = "sha256:570dffc76f0b4e9fa93cf4678a6b07d6fa446f1e5557525703160a94c0ab7968"},
-    {file = "jsonschema_rs-0.25.1-cp39-none-win_amd64.whl", hash = "sha256:9117e105f979f11f55ae940949a544e7e1a304b56ae65f535fa82cc8af4dc2e1"},
-    {file = "jsonschema_rs-0.25.1.tar.gz", hash = "sha256:f2fe71253bb0315061a5025b9336fd49660bca4094b04948f53e3acfd4197a64"},
+    {file = "jsonschema_rs-0.20.0-cp310-cp310-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:d4b12f8aaec5037529fd11e5f71032cb53d44e8e2236bb7c3fb35e6efc7ce7f2"},
+    {file = "jsonschema_rs-0.20.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:25d512c47c5c391020c9fc4223f270cf42fbdd39b2906dbc894fe0205168b8f8"},
+    {file = "jsonschema_rs-0.20.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e4d449a8c2d67c774b8719964cf4dc8eb453a6c665ddf0815780dbcc46a31be"},
+    {file = "jsonschema_rs-0.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60e14bd30306f300d194d6053a8b7dc3723bac20edc2c27db055e45bcc02687c"},
+    {file = "jsonschema_rs-0.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ea9cd8058c6d8ace05fd60a4e11d5bd933f4c21d55c4cccb2bdb6faba9b0319"},
+    {file = "jsonschema_rs-0.20.0-cp310-none-win32.whl", hash = "sha256:ef3198e43addd93619242a30ba40962521b384d68c05507fc680b549d95f7cc0"},
+    {file = "jsonschema_rs-0.20.0-cp310-none-win_amd64.whl", hash = "sha256:ab5a5c6b7282242c64bfc812c10d72dcbd9f5fe083cf81ae94de3cc2da7f0e1e"},
+    {file = "jsonschema_rs-0.20.0-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:2f76153d57c8c3778829e14867dd6479eaba17f56e2ba42da82494663200b37a"},
+    {file = "jsonschema_rs-0.20.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:1a2b24871ade985580a3f10cfde2a52673823163813fe311abffb30e0aeb4181"},
+    {file = "jsonschema_rs-0.20.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6bf5afaa6e80aa59fae06ca92efb1f8e29b2679f8f8884585272f7c100f04c69"},
+    {file = "jsonschema_rs-0.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42d180b318653184eb69d9641dfded6b2d59c88db8fb82012d3d20e1582af5cd"},
+    {file = "jsonschema_rs-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7aa67bf6338fbce3a2a3f9f408413aad7a72593ed73c846bc2667a20b747327f"},
+    {file = "jsonschema_rs-0.20.0-cp311-none-win32.whl", hash = "sha256:55c255ca6ee44177b7b5c773a8edb25af34be0d6a454e602be92cc183d6dcbe7"},
+    {file = "jsonschema_rs-0.20.0-cp311-none-win_amd64.whl", hash = "sha256:3b6effefdef590854522517b84081214b46a8fba9a5d60c538c6f1ff819609c5"},
+    {file = "jsonschema_rs-0.20.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8b9d044ecdef9a15e350a35e950c9797c804f185b547bcb56bb91fef9bf31827"},
+    {file = "jsonschema_rs-0.20.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:d43b6a65c159f7aed82dca846f93a4c5ffd013ff0c87a5668a645a81792c8001"},
+    {file = "jsonschema_rs-0.20.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9a6500934be21fe64bd65d9e75a67941b675091b8e2154df0a04f5b57073b8bf"},
+    {file = "jsonschema_rs-0.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41e42c80eed641a848ee38039291e6ca90e61de1a0b695e706894b175f45c741"},
+    {file = "jsonschema_rs-0.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c4e0945cb1ff4d183e855ae975839d648df24604d71827951f57a8b7edabb8ca"},
+    {file = "jsonschema_rs-0.20.0-cp312-none-win32.whl", hash = "sha256:00016bfdc132aa8c728fe012e9ed2b5c9d0d3dd5c37368990d58288e121a6d79"},
+    {file = "jsonschema_rs-0.20.0-cp312-none-win_amd64.whl", hash = "sha256:2c5abcf6185a4eea7185aadb132f92f6bc1d808d3debe775f0e4608baba8501e"},
+    {file = "jsonschema_rs-0.20.0-cp38-cp38-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:e51888f8c6c6434fc4037db71fe366c78d3bec8b8b200b6fc70d80266b932d77"},
+    {file = "jsonschema_rs-0.20.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:7ff31a9bb78813e2d3331aa0e4b558d34d7aaa89ab518b2313ecd53c0b3fb4ef"},
+    {file = "jsonschema_rs-0.20.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c7dfb51026ce11ca5b657022a149b7324c81bbe8ff43b57439421b0b57d623ce"},
+    {file = "jsonschema_rs-0.20.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3278fd2f0a47a0e479b551f526778da76006798dd0fc3c19155223b402b110cf"},
+    {file = "jsonschema_rs-0.20.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6cc6b6935e6a8716b532b09f231d37e6dd39fa5bec3d87aad036a13206e601bd"},
+    {file = "jsonschema_rs-0.20.0-cp38-none-win32.whl", hash = "sha256:8ae5f0a04dd4ed2a801df814e67436b6c2cafc127485003382e24a7831f46be3"},
+    {file = "jsonschema_rs-0.20.0-cp38-none-win_amd64.whl", hash = "sha256:ee28d48e8dd9f3da8d5dbe190ff769940a606792be16eeb1fe23a62ec0900297"},
+    {file = "jsonschema_rs-0.20.0-cp39-cp39-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:2a698ba8170dbb9fc32e1d0043c8f85903ffbcca56d7dc9ad8a9f169c72eae60"},
+    {file = "jsonschema_rs-0.20.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a4dcba330d2196f7af8229aca43178bdcacd8a393c76dee7b3763e7e2ac40457"},
+    {file = "jsonschema_rs-0.20.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0afa2f4b2e4cd6688866a490f3d9d9bfa97a7f19aabd860cfc1c00b54f957a5e"},
+    {file = "jsonschema_rs-0.20.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18acb318a367fdae7161126e36ecbc005b713684b7178ba853efdcac22d3f41f"},
+    {file = "jsonschema_rs-0.20.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75d0c7a497dbd59369018d6056f5ff54bf955ca385d186bfcf3529432323686f"},
+    {file = "jsonschema_rs-0.20.0-cp39-none-win32.whl", hash = "sha256:16d670954877226b7ea66d777e7aba9ca0b6c70772630af67c836aa1e99ba143"},
+    {file = "jsonschema_rs-0.20.0-cp39-none-win_amd64.whl", hash = "sha256:12f62a745ee72a5ce109f7412d0f8c55f510158c7a69171d261f1da9bc8b4059"},
+    {file = "jsonschema_rs-0.20.0.tar.gz", hash = "sha256:f76d52b7755d184844f1bfedc209c5107b5be3b6b2ae8531db4a0e563b8317ae"},
 ]
 
 [package.extras]
@@ -502,13 +495,13 @@ tests = ["flask (>=2.2.5)", "hypothesis (>=6.79.4)", "pytest (>=7.4.4)"]
 
 [[package]]
 name = "langchain-core"
-version = "0.3.36"
+version = "0.3.40"
 description = "Building applications with LLMs through composability"
 optional = true
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "langchain_core-0.3.36-py3-none-any.whl", hash = "sha256:8410311862c7c674e4f3f120cfd8d1f3d003d6e7d8cb8f934746e222f7e865d9"},
-    {file = "langchain_core-0.3.36.tar.gz", hash = "sha256:dffdce8a554905f53f33c1d6a40633a45a8d47c17c5792753891dd73941cd57a"},
+    {file = "langchain_core-0.3.40-py3-none-any.whl", hash = "sha256:9f31358741f10a13db8531e8288b8a5ae91904018c5c2e6f739d6645a98fca03"},
+    {file = "langchain_core-0.3.40.tar.gz", hash = "sha256:893a238b38491967c804662c1ec7c3e6ebaf223d1125331249c3cf3862ff2746"},
 ]
 
 [package.dependencies]
@@ -525,46 +518,47 @@ typing-extensions = ">=4.7"
 
 [[package]]
 name = "langgraph"
-version = "0.2.74"
+version = "0.3.1"
 description = "Building stateful, multi-actor applications with LLMs"
 optional = true
 python-versions = "<4.0,>=3.9.0"
 files = [
-    {file = "langgraph-0.2.74-py3-none-any.whl", hash = "sha256:91a522df764e66068f1a6de09ea748cea0687912838f29218c1d1b92b1ca025f"},
-    {file = "langgraph-0.2.74.tar.gz", hash = "sha256:db6e63e0771e2e8fb17dc0e040007b32f009e0f114e35d8348e336eb15f068e5"},
+    {file = "langgraph-0.3.1-py3-none-any.whl", hash = "sha256:212e1220d6a2af27048109604c816ccfbceb53a9aa93721be874305d8e28b7f5"},
+    {file = "langgraph-0.3.1.tar.gz", hash = "sha256:81cb89c381b089a20eac9a247f7ebcf3f41c922ac79e06dbcc4fc136c6f73dd5"},
 ]
 
 [package.dependencies]
-langchain-core = ">=0.2.43,<0.3.0 || >0.3.0,<0.3.1 || >0.3.1,<0.3.2 || >0.3.2,<0.3.3 || >0.3.3,<0.3.4 || >0.3.4,<0.3.5 || >0.3.5,<0.3.6 || >0.3.6,<0.3.7 || >0.3.7,<0.3.8 || >0.3.8,<0.3.9 || >0.3.9,<0.3.10 || >0.3.10,<0.3.11 || >0.3.11,<0.3.12 || >0.3.12,<0.3.13 || >0.3.13,<0.3.14 || >0.3.14,<0.3.15 || >0.3.15,<0.3.16 || >0.3.16,<0.3.17 || >0.3.17,<0.3.18 || >0.3.18,<0.3.19 || >0.3.19,<0.3.20 || >0.3.20,<0.3.21 || >0.3.21,<0.3.22 || >0.3.22,<0.4.0"
+langchain-core = ">=0.1,<0.4"
 langgraph-checkpoint = ">=2.0.10,<3.0.0"
+langgraph-prebuilt = ">=0.1.1,<0.2"
 langgraph-sdk = ">=0.1.42,<0.2.0"
 
 [[package]]
 name = "langgraph-api"
-version = "0.0.24"
+version = "0.0.27"
 description = ""
 optional = true
 python-versions = "<4.0,>=3.11.0"
 files = [
-    {file = "langgraph_api-0.0.24-py3-none-any.whl", hash = "sha256:26c4fb7aeefa3ac2ffadcc4cd6ff7e7afcc7d607e92b0c645cc541f89ad23af5"},
-    {file = "langgraph_api-0.0.24.tar.gz", hash = "sha256:53eac22cf7d2bc436ed77e0790027a939534174001a27db88cd0e20af2161bcd"},
+    {file = "langgraph_api-0.0.27-py3-none-any.whl", hash = "sha256:9b21742238b15b8db9c2d3fd760a670332c8897d0bcbbd9d82e43b6ac15a7937"},
+    {file = "langgraph_api-0.0.27.tar.gz", hash = "sha256:c21eb2b7fe3b93998379f7b13ad7d23b3ef06ab821b008c6b12b954acfb587ec"},
 ]
 
 [package.dependencies]
 cryptography = ">=43.0.3,<44.0.0"
-httpx = ">=0.27.0"
-jsonschema-rs = ">=0.25.0,<0.26.0"
+httpx = ">=0.25.0"
+jsonschema-rs = ">=0.20.0,<0.21.0"
 langchain-core = ">=0.2.38,<0.4.0"
-langgraph = ">=0.2.56,<0.3.0"
-langgraph-checkpoint = ">=2.0.7,<3.0"
-langgraph-sdk = ">=0.1.51,<0.2.0"
+langgraph = ">=0.2.56,<0.4.0"
+langgraph-checkpoint = ">=2.0.15,<3.0"
+langgraph-sdk = ">=0.1.53,<0.2.0"
 langsmith = ">=0.1.63,<0.4.0"
-orjson = ">=3.10.1"
+orjson = ">=3.9.7"
 pyjwt = ">=2.9.0,<3.0.0"
 sse-starlette = ">=2.1.0,<2.2.0"
 starlette = ">=0.38.6"
-structlog = ">=24.4.0,<25.0.0"
-tenacity = ">=8.3.0,<10"
+structlog = ">=23.1.0,<24.0.0"
+tenacity = ">=8.0.0"
 uvicorn = ">=0.26.0"
 watchfiles = ">=0.13"
 
@@ -583,15 +577,30 @@ files = [
 langchain-core = ">=0.2.38,<0.4"
 msgpack = ">=1.1.0,<2.0.0"
 
+[[package]]
+name = "langgraph-prebuilt"
+version = "0.1.1"
+description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
+optional = true
+python-versions = "<4.0.0,>=3.9.0"
+files = [
+    {file = "langgraph_prebuilt-0.1.1-py3-none-any.whl", hash = "sha256:148a9558a36ec7e83cc6512f3521425c862b0463251ae0242ade52a448c54e78"},
+    {file = "langgraph_prebuilt-0.1.1.tar.gz", hash = "sha256:420a748ff93842f2b1a345a0c1ca3939d2bc7a2d46c20e9a9a0d8f148152cc47"},
+]
+
+[package.dependencies]
+langchain-core = ">=0.2.43,<0.3.0 || >0.3.0,<0.3.1 || >0.3.1,<0.3.2 || >0.3.2,<0.3.3 || >0.3.3,<0.3.4 || >0.3.4,<0.3.5 || >0.3.5,<0.3.6 || >0.3.6,<0.3.7 || >0.3.7,<0.3.8 || >0.3.8,<0.3.9 || >0.3.9,<0.3.10 || >0.3.10,<0.3.11 || >0.3.11,<0.3.12 || >0.3.12,<0.3.13 || >0.3.13,<0.3.14 || >0.3.14,<0.3.15 || >0.3.15,<0.3.16 || >0.3.16,<0.3.17 || >0.3.17,<0.3.18 || >0.3.18,<0.3.19 || >0.3.19,<0.3.20 || >0.3.20,<0.3.21 || >0.3.21,<0.3.22 || >0.3.22,<0.4.0"
+langgraph-checkpoint = ">=2.0.10,<3.0.0"
+
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.51"
+version = "0.1.53"
 description = "SDK for interacting with LangGraph API"
 optional = true
 python-versions = "<4.0.0,>=3.9.0"
 files = [
-    {file = "langgraph_sdk-0.1.51-py3-none-any.whl", hash = "sha256:ce2b58466d1700d06149782ed113157a8694a6d7932c801f316cd13fab315fe4"},
-    {file = "langgraph_sdk-0.1.51.tar.gz", hash = "sha256:dea1363e72562cb1e82a2d156be8d5b1a69ff3fe8815eee0e1e7a2f423242ec1"},
+    {file = "langgraph_sdk-0.1.53-py3-none-any.whl", hash = "sha256:4fab62caad73661ffe4c3ababedcd0d7bfaaba986bee4416b9c28948458a3af5"},
+    {file = "langgraph_sdk-0.1.53.tar.gz", hash = "sha256:12906ed965905fa27e0c28d9fa07dc6fd89e6895ff321ff049fdf3965d057cc4"},
 ]
 
 [package.dependencies]
@@ -600,18 +609,19 @@ orjson = ">=3.10.1"
 
 [[package]]
 name = "langsmith"
-version = "0.3.8"
+version = "0.3.11"
 description = "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform."
 optional = true
 python-versions = "<4.0,>=3.9"
 files = [
-    {file = "langsmith-0.3.8-py3-none-any.whl", hash = "sha256:fbb9dd97b0f090219447fca9362698d07abaeda1da85aa7cc6ec6517b36581b1"},
-    {file = "langsmith-0.3.8.tar.gz", hash = "sha256:97f9bebe0b7cb0a4f278e6ff30ae7d5ededff3883b014442ec6d7d575b02a0f1"},
+    {file = "langsmith-0.3.11-py3-none-any.whl", hash = "sha256:0cca22737ef07d3b038a437c141deda37e00add56022582680188b681bec095e"},
+    {file = "langsmith-0.3.11.tar.gz", hash = "sha256:ddf29d24352e99de79c9618aaf95679214324e146c5d3d9475a7ddd2870018b1"},
 ]
 
 [package.dependencies]
 httpx = ">=0.23.0,<1"
 orjson = {version = ">=3.9.14,<4.0.0", markers = "platform_python_implementation != \"PyPy\""}
+packaging = ">=23.2"
 pydantic = [
     {version = ">=1,<3", markers = "python_full_version < \"3.12.4\""},
     {version = ">=2.7.4,<3.0.0", markers = "python_full_version >= \"3.12.4\""},
@@ -697,6 +707,58 @@ files = [
     {file = "msgpack-1.1.0.tar.gz", hash = "sha256:dd432ccc2c72b914e4cb77afce64aab761c1137cc698be3984eee260bcb2896e"},
 ]
 
+[[package]]
+name = "msgspec"
+version = "0.19.0"
+description = "A fast serialization and validation library, with builtin support for JSON, MessagePack, YAML, and TOML."
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "msgspec-0.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8dd848ee7ca7c8153462557655570156c2be94e79acec3561cf379581343259"},
+    {file = "msgspec-0.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0553bbc77662e5708fe66aa75e7bd3e4b0f209709c48b299afd791d711a93c36"},
+    {file = "msgspec-0.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe2c4bf29bf4e89790b3117470dea2c20b59932772483082c468b990d45fb947"},
+    {file = "msgspec-0.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00e87ecfa9795ee5214861eab8326b0e75475c2e68a384002aa135ea2a27d909"},
+    {file = "msgspec-0.19.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3c4ec642689da44618f68c90855a10edbc6ac3ff7c1d94395446c65a776e712a"},
+    {file = "msgspec-0.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2719647625320b60e2d8af06b35f5b12d4f4d281db30a15a1df22adb2295f633"},
+    {file = "msgspec-0.19.0-cp310-cp310-win_amd64.whl", hash = "sha256:695b832d0091edd86eeb535cd39e45f3919f48d997685f7ac31acb15e0a2ed90"},
+    {file = "msgspec-0.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aa77046904db764b0462036bc63ef71f02b75b8f72e9c9dd4c447d6da1ed8f8e"},
+    {file = "msgspec-0.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:047cfa8675eb3bad68722cfe95c60e7afabf84d1bd8938979dd2b92e9e4a9551"},
+    {file = "msgspec-0.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e78f46ff39a427e10b4a61614a2777ad69559cc8d603a7c05681f5a595ea98f7"},
+    {file = "msgspec-0.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c7adf191e4bd3be0e9231c3b6dc20cf1199ada2af523885efc2ed218eafd011"},
+    {file = "msgspec-0.19.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f04cad4385e20be7c7176bb8ae3dca54a08e9756cfc97bcdb4f18560c3042063"},
+    {file = "msgspec-0.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45c8fb410670b3b7eb884d44a75589377c341ec1392b778311acdbfa55187716"},
+    {file = "msgspec-0.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:70eaef4934b87193a27d802534dc466778ad8d536e296ae2f9334e182ac27b6c"},
+    {file = "msgspec-0.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f98bd8962ad549c27d63845b50af3f53ec468b6318400c9f1adfe8b092d7b62f"},
+    {file = "msgspec-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:43bbb237feab761b815ed9df43b266114203f53596f9b6e6f00ebd79d178cdf2"},
+    {file = "msgspec-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4cfc033c02c3e0aec52b71710d7f84cb3ca5eb407ab2ad23d75631153fdb1f12"},
+    {file = "msgspec-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d911c442571605e17658ca2b416fd8579c5050ac9adc5e00c2cb3126c97f73bc"},
+    {file = "msgspec-0.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:757b501fa57e24896cf40a831442b19a864f56d253679f34f260dcb002524a6c"},
+    {file = "msgspec-0.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5f0f65f29b45e2816d8bded36e6b837a4bf5fb60ec4bc3c625fa2c6da4124537"},
+    {file = "msgspec-0.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:067f0de1c33cfa0b6a8206562efdf6be5985b988b53dd244a8e06f993f27c8c0"},
+    {file = "msgspec-0.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f12d30dd6266557aaaf0aa0f9580a9a8fbeadfa83699c487713e355ec5f0bd86"},
+    {file = "msgspec-0.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82b2c42c1b9ebc89e822e7e13bbe9d17ede0c23c187469fdd9505afd5a481314"},
+    {file = "msgspec-0.19.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19746b50be214a54239aab822964f2ac81e38b0055cca94808359d779338c10e"},
+    {file = "msgspec-0.19.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60ef4bdb0ec8e4ad62e5a1f95230c08efb1f64f32e6e8dd2ced685bcc73858b5"},
+    {file = "msgspec-0.19.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac7f7c377c122b649f7545810c6cd1b47586e3aa3059126ce3516ac7ccc6a6a9"},
+    {file = "msgspec-0.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a5bc1472223a643f5ffb5bf46ccdede7f9795078194f14edd69e3aab7020d327"},
+    {file = "msgspec-0.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:317050bc0f7739cb30d257ff09152ca309bf5a369854bbf1e57dffc310c1f20f"},
+    {file = "msgspec-0.19.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15c1e86fff77184c20a2932cd9742bf33fe23125fa3fcf332df9ad2f7d483044"},
+    {file = "msgspec-0.19.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3b5541b2b3294e5ffabe31a09d604e23a88533ace36ac288fa32a420aa38d229"},
+    {file = "msgspec-0.19.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f5c043ace7962ef188746e83b99faaa9e3e699ab857ca3f367b309c8e2c6b12"},
+    {file = "msgspec-0.19.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca06aa08e39bf57e39a258e1996474f84d0dd8130d486c00bec26d797b8c5446"},
+    {file = "msgspec-0.19.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:e695dad6897896e9384cf5e2687d9ae9feaef50e802f93602d35458e20d1fb19"},
+    {file = "msgspec-0.19.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3be5c02e1fee57b54130316a08fe40cca53af92999a302a6054cd451700ea7db"},
+    {file = "msgspec-0.19.0-cp39-cp39-win_amd64.whl", hash = "sha256:0684573a821be3c749912acf5848cce78af4298345cb2d7a8b8948a0a5a27cfe"},
+    {file = "msgspec-0.19.0.tar.gz", hash = "sha256:604037e7cd475345848116e89c553aa9a233259733ab51986ac924ab1b976f8e"},
+]
+
+[package.extras]
+dev = ["attrs", "coverage", "eval-type-backport", "furo", "ipython", "msgpack", "mypy", "pre-commit", "pyright", "pytest", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "tomli", "tomli_w"]
+doc = ["furo", "ipython", "sphinx", "sphinx-copybutton", "sphinx-design"]
+test = ["attrs", "eval-type-backport", "msgpack", "pytest", "pyyaml", "tomli", "tomli_w"]
+toml = ["tomli", "tomli_w"]
+yaml = ["pyyaml"]
+
 [[package]]
 name = "mypy"
 version = "1.15.0"
@@ -1278,13 +1340,13 @@ examples = ["fastapi"]
 
 [[package]]
 name = "starlette"
-version = "0.45.3"
+version = "0.46.0"
 description = "The little ASGI library that shines."
 optional = true
 python-versions = ">=3.9"
 files = [
-    {file = "starlette-0.45.3-py3-none-any.whl", hash = "sha256:dfb6d332576f136ec740296c7e8bb8c8a7125044e7c6da30744718880cdd059d"},
-    {file = "starlette-0.45.3.tar.gz", hash = "sha256:2cbcba2a75806f8a41c722141486f37c28e30a0921c5f6fe4346cb0dcee1302f"},
+    {file = "starlette-0.46.0-py3-none-any.whl", hash = "sha256:913f0798bd90ba90a9156383bcf1350a17d6259451d0d8ee27fc0cf2db609038"},
+    {file = "starlette-0.46.0.tar.gz", hash = "sha256:b359e4567456b28d473d0193f34c0de0ed49710d75ef183a74a5ce0499324f50"},
 ]
 
 [package.dependencies]
@@ -1295,18 +1357,18 @@ full = ["httpx (>=0.27.0,<0.29.0)", "itsdangerous", "jinja2", "python-multipart
 
 [[package]]
 name = "structlog"
-version = "24.4.0"
+version = "23.3.0"
 description = "Structured Logging for Python"
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "structlog-24.4.0-py3-none-any.whl", hash = "sha256:597f61e80a91cc0749a9fd2a098ed76715a1c8a01f73e336b746504d1aad7610"},
-    {file = "structlog-24.4.0.tar.gz", hash = "sha256:b27bfecede327a6d2da5fbc96bd859f114ecc398a6389d664f62085ee7ae6fc4"},
+    {file = "structlog-23.3.0-py3-none-any.whl", hash = "sha256:d6922a88ceabef5b13b9eda9c4043624924f60edbb00397f4d193bd754cde60a"},
+    {file = "structlog-23.3.0.tar.gz", hash = "sha256:24b42b914ac6bc4a4e6f716e82ac70d7fb1e8c3b1035a765591953bfc37101a5"},
 ]
 
 [package.extras]
-dev = ["freezegun (>=0.2.8)", "mypy (>=1.4)", "pretend", "pytest (>=6.0)", "pytest-asyncio (>=0.17)", "rich", "simplejson", "twisted"]
-docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-mermaid", "sphinxext-opengraph", "twisted"]
+dev = ["structlog[tests,typing]"]
+docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-mermaid", "sphinxext-opengraph", "twisted"]
 tests = ["freezegun (>=0.2.8)", "pretend", "pytest (>=6.0)", "pytest-asyncio (>=0.17)", "simplejson"]
 typing = ["mypy (>=1.4)", "rich", "twisted"]
 
@@ -1655,4 +1717,4 @@ inmem = ["langgraph-api", "python-dotenv"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.9.0,<4.0"
-content-hash = "efd4f33499434405e0d130f7f561f9ef454b8c7906c2ef9d119d3638bfd3cc33"
+content-hash = "d0e2bdcb600ad031867413025fcc58bb162609209359d63ca99a77060cf8cbb4"

libs/cli/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-cli"
-version = "0.1.72"
+version = "0.1.76"
 description = "CLI for interacting with LangGraph API"
 authors = []
 license = "MIT"
@@ -14,7 +14,7 @@ langgraph = "langgraph_cli.cli:cli"
 [tool.poetry.dependencies]
 python = "^3.9.0,<4.0"
 click = "^8.1.7"
-langgraph-api = { version = ">=0.0.24,<0.1.0", optional = true, python = ">=3.11,<4.0" }
+langgraph-api = { version = ">=0.0.27,<0.1.0", optional = true, python = ">=3.11,<4.0" }
 python-dotenv = { version = ">=0.8.0", optional = true }
 
 [tool.poetry.group.dev.dependencies]
@@ -25,6 +25,7 @@ pytest-asyncio = "^0.21.1"
 pytest-mock = "^3.11.1"
 pytest-watch = "^4.2.0"
 mypy = "^1.10.0"
+msgspec = "^0.19.0"
 
 [tool.poetry.extras]
 inmem = ["langgraph-api", "python-dotenv"]

libs/cli/schemas/schema.json

@@ -0,0 +1,470 @@
+{
+  "$ref": "#/$defs/Config",
+  "$defs": {
+    "Config": {
+      "title": "Config",
+      "description": "Top-level config for langgraph-cli or similar deployment tooling.",
+      "type": "object",
+      "required": [],
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "python_version": {
+              "type": "string",
+              "description": "Optional. Python version in 'major.minor' format (e.g. '3.11').\nMust be at least 3.11 or greater for this deployment to function properly.\n",
+              "enum": [
+                "3.11",
+                "3.12"
+              ]
+            },
+            "pip_config_file": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+            },
+            "auth": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/AuthConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Custom authentication config, including the path to your Python auth logic and\nthe OpenAPI security definitions it uses.\n"
+            },
+            "dependencies": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "List of Python dependencies to install, either from PyPI or local paths.\n"
+            },
+            "dockerfile_lines": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Optional. Additional Docker instructions that will be appended to your base Dockerfile.\n\nUseful for installing OS packages, setting environment variables, etc."
+            },
+            "env": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "description": "Optional. Environment variables to set for your deployment.\n\n- If given as a dict, keys are variable names and values are their values.\n- If given as a string, it must be a path to a file containing lines in KEY=VALUE format.\n\nenv=\".env\n"
+            },
+            "graphs": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              },
+              "description": "Optional. Named definitions of graphs, each pointing to a Python object.\n\n\nGraphs can be StateGraph, @entrypoint, or any other Pregel object OR they can point to (async) context\nmanagers that accept a single configuration argument (of type RunnableConfig) and return a pregel object\n(instance of Stategraph, etc.).\n"
+            },
+            "http": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/HttpConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
+            },
+            "store": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/StoreConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in long-term memory store, including semantic search indexing.\n\nIf omitted, no vector index is set up (the object store will still be present, however).\n"
+            },
+            "ui": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file.\n"
+            }
+          },
+          "required": [
+            "dependencies",
+            "graphs"
+          ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "node_version": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "enum": [
+                    "20"
+                  ]
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Node.js version as a major version (e.g. '20'), if your deployment needs Node.\nMust be >= 20 if provided.\n"
+            },
+            "auth": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/AuthConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Custom authentication config, including the path to your Python auth logic and\nthe OpenAPI security definitions it uses.\n"
+            },
+            "dependencies": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "List of Python dependencies to install, either from PyPI or local paths.\n"
+            },
+            "dockerfile_lines": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Optional. Additional Docker instructions that will be appended to your base Dockerfile.\n\nUseful for installing OS packages, setting environment variables, etc."
+            },
+            "env": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "description": "Optional. Environment variables to set for your deployment.\n\n- If given as a dict, keys are variable names and values are their values.\n- If given as a string, it must be a path to a file containing lines in KEY=VALUE format.\n\nenv=\".env\n"
+            },
+            "graphs": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              },
+              "description": "Optional. Named definitions of graphs, each pointing to a Python object.\n\n\nGraphs can be StateGraph, @entrypoint, or any other Pregel object OR they can point to (async) context\nmanagers that accept a single configuration argument (of type RunnableConfig) and return a pregel object\n(instance of Stategraph, etc.).\n"
+            },
+            "http": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/HttpConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
+            },
+            "store": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/StoreConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in long-term memory store, including semantic search indexing.\n\nIf omitted, no vector index is set up (the object store will still be present, however).\n"
+            },
+            "ui": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file.\n"
+            }
+          },
+          "required": [
+            "node_version",
+            "graphs"
+          ]
+        }
+      ]
+    },
+    "AuthConfig": {
+      "title": "AuthConfig",
+      "description": "Configuration for custom authentication logic and how it integrates into the OpenAPI spec.",
+      "type": "object",
+      "properties": {
+        "disable_studio_auth": {
+          "type": "boolean",
+          "description": "Optional. Whether to disable LangSmith API-key authentication for requests originating the Studio.\n\nDefaults to False, meaning that if a particular header is set, the server will verify the `x-api-key` header\nvalue is a valid API key for the deployment's workspace. If True, all requests will go through your custom\nauthentication logic, regardless of origin of the request.\n"
+        },
+        "openapi": {
+          "$ref": "#/$defs/SecurityConfig",
+          "description": "Required. Detailed security configuration that merges into your deployment's OpenAPI spec.\n\n{\n}\n}\n}\n},\n]\n}\n"
+        },
+        "path": {
+          "type": "string",
+          "description": "Required. Path to an instance of the Auth() class that implements custom authentication.\n"
+        }
+      },
+      "required": []
+    },
+    "SecurityConfig": {
+      "title": "SecurityConfig",
+      "description": "Configuration for OpenAPI security definitions and requirements.\n\nUseful for specifying global or path-level authentication and authorization flows\n(e.g., OAuth2, API key headers, etc.).",
+      "type": "object",
+      "properties": {
+        "paths": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          },
+          "description": "Optional. Path-specific security overrides.\n\n- Keys that are HTTP methods (e.g., \"GET\", \"POST\"),\n- Values are lists of security definitions (just like `security`) for that method.\n"
+        },
+        "security": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          "description": "Optional. Global security requirements across all endpoints.\n\nEach element in the list maps a security scheme (e.g. \"OAuth2\") to a list of scopes (e.g. [\"read\", \"write\"])."
+        },
+        "securitySchemes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object"
+          },
+          "description": "Required. Dict describing each security scheme recognized by your OpenAPI spec.\n\nKeys are scheme names (e.g. \"OAuth2\", \"ApiKeyAuth\") and values are their definitions."
+        }
+      },
+      "required": []
+    },
+    "HttpConfig": {
+      "title": "HttpConfig",
+      "description": "Configuration for the built-in HTTP server that powers your deployment's routes and endpoints.",
+      "type": "object",
+      "properties": {
+        "app": {
+          "type": "string",
+          "description": "Optional. Import path to a custom Starlette/FastAPI application to mount.\n"
+        },
+        "cors": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CorsConfig"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Optional. Defines CORS restrictions. If omitted, no special rules are set and\ncross-origin behavior depends on default server settings.\n"
+        },
+        "disable_assistants": {
+          "type": "boolean",
+          "description": "Optional. If True, /assistants routes are removed from the server.\n\nDefault is False (meaning /assistants is enabled).\n"
+        },
+        "disable_meta": {
+          "type": "boolean",
+          "description": "Optional. If True, all meta endpoints (/ok, /info, /metrics, /docs) are disabled.\n\nDefault is False.\n"
+        },
+        "disable_runs": {
+          "type": "boolean",
+          "description": "Optional. If True, /runs routes are removed.\n\nDefault is False.\n"
+        },
+        "disable_store": {
+          "type": "boolean",
+          "description": "Optional. If True, /store routes are removed, disabling direct store interactions via HTTP.\n\nDefault is False.\n"
+        },
+        "disable_threads": {
+          "type": "boolean",
+          "description": "Optional. If True, /threads routes are removed.\n\nDefault is False.\n"
+        }
+      },
+      "required": []
+    },
+    "CorsConfig": {
+      "title": "CorsConfig",
+      "description": "Specifies Cross-Origin Resource Sharing (CORS) rules for your server.\n\nIf omitted, defaults are typically very restrictive (often no cross-origin requests).\nConfigure carefully if you want to allow usage from browsers hosted on other domains.",
+      "type": "object",
+      "properties": {
+        "allow_credentials": {
+          "type": "boolean",
+          "description": "Optional. If True, cross-origin requests can include credentials (cookies, auth headers).\n\nDefault False to avoid accidentally exposing secured endpoints to untrusted sites.\n"
+        },
+        "allow_headers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. HTTP headers that can be used in cross-origin requests (e.g. [\"Content-Type\", \"Authorization\"])."
+        },
+        "allow_methods": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. HTTP methods permitted for cross-origin requests (e.g. [\"GET\", \"POST\"]).\n\nDefault might be [\"GET\", \"POST\", \"OPTIONS\"] depending on your server framework.\n"
+        },
+        "allow_origin_regex": {
+          "type": "string",
+          "description": "Optional. A regex pattern for matching allowed origins, used if you have dynamic subdomains.\n"
+        },
+        "allow_origins": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. List of allowed origins (e.g., \"https://example.com\").\n\nDefault is often an empty list (no external origins).\nUse \"*\" only if you trust all origins, as that bypasses most restrictions.\n"
+        },
+        "expose_headers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. List of headers that browsers are allowed to read from the response in cross-origin contexts."
+        },
+        "max_age": {
+          "type": "integer",
+          "description": "Optional. How many seconds the browser may cache preflight responses.\n\nDefault might be 600 (10 minutes). Larger values reduce preflight requests but can cause stale configurations.\n"
+        }
+      },
+      "required": []
+    },
+    "StoreConfig": {
+      "title": "StoreConfig",
+      "description": "Configuration for the built-in long-term memory store.\n\nThis store can optionally perform semantic search. If you omit `index`,\nthe store will just handle traditional (non-embedded) data without vector lookups.",
+      "type": "object",
+      "properties": {
+        "index": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/IndexConfig"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "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": []
+    },
+    "IndexConfig": {
+      "title": "IndexConfig",
+      "description": "Configuration for indexing documents for semantic search in the store.\n\nThis governs how text is converted into embeddings and stored for vector-based lookups.",
+      "type": "object",
+      "properties": {
+        "dims": {
+          "type": "integer",
+          "description": "Required. Dimensionality of the embedding vectors you will store.\n\nMust match the output dimension of your selected embedding model or custom embed function.\nIf mismatched, you will likely encounter shape/size errors when inserting or querying vectors.\n\n"
+        },
+        "embed": {
+          "type": "string",
+          "description": "Required. Identifier or reference to the embedding model or a custom embedding function.\n\n- \"my_custom_embed\" if it's a known alias in your system\n"
+        },
+        "fields": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Optional. List of JSON fields to extract before generating embeddings.\n\nDefaults to [\"$\"], which means the entire JSON object is embedded as one piece of text.\nIf you provide multiple fields (e.g. [\"title\", \"content\"]), each is extracted and embedded separately,\noften saving token usage if you only care about certain parts of the data.\n"
+        }
+      },
+      "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"
+        }
+      },
+      "required": []
+    }
+  },
+  "title": "LangGraph CLI Configuration",
+  "description": "Configuration schema for langgraph-cli",
+  "version": "v0"
+}

libs/cli/schemas/schema.v0.json

@@ -0,0 +1,470 @@
+{
+  "$ref": "#/$defs/Config",
+  "$defs": {
+    "Config": {
+      "title": "Config",
+      "description": "Top-level config for langgraph-cli or similar deployment tooling.",
+      "type": "object",
+      "required": [],
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "python_version": {
+              "type": "string",
+              "description": "Optional. Python version in 'major.minor' format (e.g. '3.11').\nMust be at least 3.11 or greater for this deployment to function properly.\n",
+              "enum": [
+                "3.11",
+                "3.12"
+              ]
+            },
+            "pip_config_file": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+            },
+            "auth": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/AuthConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Custom authentication config, including the path to your Python auth logic and\nthe OpenAPI security definitions it uses.\n"
+            },
+            "dependencies": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "List of Python dependencies to install, either from PyPI or local paths.\n"
+            },
+            "dockerfile_lines": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Optional. Additional Docker instructions that will be appended to your base Dockerfile.\n\nUseful for installing OS packages, setting environment variables, etc."
+            },
+            "env": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "description": "Optional. Environment variables to set for your deployment.\n\n- If given as a dict, keys are variable names and values are their values.\n- If given as a string, it must be a path to a file containing lines in KEY=VALUE format.\n\nenv=\".env\n"
+            },
+            "graphs": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              },
+              "description": "Optional. Named definitions of graphs, each pointing to a Python object.\n\n\nGraphs can be StateGraph, @entrypoint, or any other Pregel object OR they can point to (async) context\nmanagers that accept a single configuration argument (of type RunnableConfig) and return a pregel object\n(instance of Stategraph, etc.).\n"
+            },
+            "http": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/HttpConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
+            },
+            "store": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/StoreConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in long-term memory store, including semantic search indexing.\n\nIf omitted, no vector index is set up (the object store will still be present, however).\n"
+            },
+            "ui": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file.\n"
+            }
+          },
+          "required": [
+            "dependencies",
+            "graphs"
+          ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "node_version": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "enum": [
+                    "20"
+                  ]
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Node.js version as a major version (e.g. '20'), if your deployment needs Node.\nMust be >= 20 if provided.\n"
+            },
+            "auth": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/AuthConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Custom authentication config, including the path to your Python auth logic and\nthe OpenAPI security definitions it uses.\n"
+            },
+            "dependencies": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "List of Python dependencies to install, either from PyPI or local paths.\n"
+            },
+            "dockerfile_lines": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Optional. Additional Docker instructions that will be appended to your base Dockerfile.\n\nUseful for installing OS packages, setting environment variables, etc."
+            },
+            "env": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "description": "Optional. Environment variables to set for your deployment.\n\n- If given as a dict, keys are variable names and values are their values.\n- If given as a string, it must be a path to a file containing lines in KEY=VALUE format.\n\nenv=\".env\n"
+            },
+            "graphs": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              },
+              "description": "Optional. Named definitions of graphs, each pointing to a Python object.\n\n\nGraphs can be StateGraph, @entrypoint, or any other Pregel object OR they can point to (async) context\nmanagers that accept a single configuration argument (of type RunnableConfig) and return a pregel object\n(instance of Stategraph, etc.).\n"
+            },
+            "http": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/HttpConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
+            },
+            "store": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/StoreConfig"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Configuration for the built-in long-term memory store, including semantic search indexing.\n\nIf omitted, no vector index is set up (the object store will still be present, however).\n"
+            },
+            "ui": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file.\n"
+            }
+          },
+          "required": [
+            "node_version",
+            "graphs"
+          ]
+        }
+      ]
+    },
+    "AuthConfig": {
+      "title": "AuthConfig",
+      "description": "Configuration for custom authentication logic and how it integrates into the OpenAPI spec.",
+      "type": "object",
+      "properties": {
+        "disable_studio_auth": {
+          "type": "boolean",
+          "description": "Optional. Whether to disable LangSmith API-key authentication for requests originating the Studio.\n\nDefaults to False, meaning that if a particular header is set, the server will verify the `x-api-key` header\nvalue is a valid API key for the deployment's workspace. If True, all requests will go through your custom\nauthentication logic, regardless of origin of the request.\n"
+        },
+        "openapi": {
+          "$ref": "#/$defs/SecurityConfig",
+          "description": "Required. Detailed security configuration that merges into your deployment's OpenAPI spec.\n\n{\n}\n}\n}\n},\n]\n}\n"
+        },
+        "path": {
+          "type": "string",
+          "description": "Required. Path to an instance of the Auth() class that implements custom authentication.\n"
+        }
+      },
+      "required": []
+    },
+    "SecurityConfig": {
+      "title": "SecurityConfig",
+      "description": "Configuration for OpenAPI security definitions and requirements.\n\nUseful for specifying global or path-level authentication and authorization flows\n(e.g., OAuth2, API key headers, etc.).",
+      "type": "object",
+      "properties": {
+        "paths": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          },
+          "description": "Optional. Path-specific security overrides.\n\n- Keys that are HTTP methods (e.g., \"GET\", \"POST\"),\n- Values are lists of security definitions (just like `security`) for that method.\n"
+        },
+        "security": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          "description": "Optional. Global security requirements across all endpoints.\n\nEach element in the list maps a security scheme (e.g. \"OAuth2\") to a list of scopes (e.g. [\"read\", \"write\"])."
+        },
+        "securitySchemes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object"
+          },
+          "description": "Required. Dict describing each security scheme recognized by your OpenAPI spec.\n\nKeys are scheme names (e.g. \"OAuth2\", \"ApiKeyAuth\") and values are their definitions."
+        }
+      },
+      "required": []
+    },
+    "HttpConfig": {
+      "title": "HttpConfig",
+      "description": "Configuration for the built-in HTTP server that powers your deployment's routes and endpoints.",
+      "type": "object",
+      "properties": {
+        "app": {
+          "type": "string",
+          "description": "Optional. Import path to a custom Starlette/FastAPI application to mount.\n"
+        },
+        "cors": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CorsConfig"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Optional. Defines CORS restrictions. If omitted, no special rules are set and\ncross-origin behavior depends on default server settings.\n"
+        },
+        "disable_assistants": {
+          "type": "boolean",
+          "description": "Optional. If True, /assistants routes are removed from the server.\n\nDefault is False (meaning /assistants is enabled).\n"
+        },
+        "disable_meta": {
+          "type": "boolean",
+          "description": "Optional. If True, all meta endpoints (/ok, /info, /metrics, /docs) are disabled.\n\nDefault is False.\n"
+        },
+        "disable_runs": {
+          "type": "boolean",
+          "description": "Optional. If True, /runs routes are removed.\n\nDefault is False.\n"
+        },
+        "disable_store": {
+          "type": "boolean",
+          "description": "Optional. If True, /store routes are removed, disabling direct store interactions via HTTP.\n\nDefault is False.\n"
+        },
+        "disable_threads": {
+          "type": "boolean",
+          "description": "Optional. If True, /threads routes are removed.\n\nDefault is False.\n"
+        }
+      },
+      "required": []
+    },
+    "CorsConfig": {
+      "title": "CorsConfig",
+      "description": "Specifies Cross-Origin Resource Sharing (CORS) rules for your server.\n\nIf omitted, defaults are typically very restrictive (often no cross-origin requests).\nConfigure carefully if you want to allow usage from browsers hosted on other domains.",
+      "type": "object",
+      "properties": {
+        "allow_credentials": {
+          "type": "boolean",
+          "description": "Optional. If True, cross-origin requests can include credentials (cookies, auth headers).\n\nDefault False to avoid accidentally exposing secured endpoints to untrusted sites.\n"
+        },
+        "allow_headers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. HTTP headers that can be used in cross-origin requests (e.g. [\"Content-Type\", \"Authorization\"])."
+        },
+        "allow_methods": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. HTTP methods permitted for cross-origin requests (e.g. [\"GET\", \"POST\"]).\n\nDefault might be [\"GET\", \"POST\", \"OPTIONS\"] depending on your server framework.\n"
+        },
+        "allow_origin_regex": {
+          "type": "string",
+          "description": "Optional. A regex pattern for matching allowed origins, used if you have dynamic subdomains.\n"
+        },
+        "allow_origins": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. List of allowed origins (e.g., \"https://example.com\").\n\nDefault is often an empty list (no external origins).\nUse \"*\" only if you trust all origins, as that bypasses most restrictions.\n"
+        },
+        "expose_headers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Optional. List of headers that browsers are allowed to read from the response in cross-origin contexts."
+        },
+        "max_age": {
+          "type": "integer",
+          "description": "Optional. How many seconds the browser may cache preflight responses.\n\nDefault might be 600 (10 minutes). Larger values reduce preflight requests but can cause stale configurations.\n"
+        }
+      },
+      "required": []
+    },
+    "StoreConfig": {
+      "title": "StoreConfig",
+      "description": "Configuration for the built-in long-term memory store.\n\nThis store can optionally perform semantic search. If you omit `index`,\nthe store will just handle traditional (non-embedded) data without vector lookups.",
+      "type": "object",
+      "properties": {
+        "index": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/IndexConfig"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "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": []
+    },
+    "IndexConfig": {
+      "title": "IndexConfig",
+      "description": "Configuration for indexing documents for semantic search in the store.\n\nThis governs how text is converted into embeddings and stored for vector-based lookups.",
+      "type": "object",
+      "properties": {
+        "dims": {
+          "type": "integer",
+          "description": "Required. Dimensionality of the embedding vectors you will store.\n\nMust match the output dimension of your selected embedding model or custom embed function.\nIf mismatched, you will likely encounter shape/size errors when inserting or querying vectors.\n\n"
+        },
+        "embed": {
+          "type": "string",
+          "description": "Required. Identifier or reference to the embedding model or a custom embedding function.\n\n- \"my_custom_embed\" if it's a known alias in your system\n"
+        },
+        "fields": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "Optional. List of JSON fields to extract before generating embeddings.\n\nDefaults to [\"$\"], which means the entire JSON object is embedded as one piece of text.\nIf you provide multiple fields (e.g. [\"title\", \"content\"]), each is extracted and embedded separately,\noften saving token usage if you only care about certain parts of the data.\n"
+        }
+      },
+      "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"
+        }
+      },
+      "required": []
+    }
+  },
+  "title": "LangGraph CLI Configuration",
+  "description": "Configuration schema for langgraph-cli",
+  "version": "v0"
+}

libs/cli/tests/unit_tests/test_config.py

@@ -33,6 +33,7 @@ def test_validate_config():
         "store": None,
         "auth": None,
         "http": None,
+        "ui": None,
         **expected_config,
     }
     actual_config = validate_config(expected_config)
@@ -52,6 +53,7 @@ def test_validate_config():
         "store": None,
         "auth": None,
         "http": None,
+        "ui": None,
     }
     actual_config = validate_config(expected_config)
     assert actual_config == expected_config
@@ -467,6 +469,7 @@ def test_config_to_docker_nodejs():
                 "node_version": "20",
                 "graphs": graphs,
                 "dockerfile_lines": ["ARG meow", "ARG foo"],
+                "ui": {"agent": "./graphs/agent.ui.jsx"},
             }
         ),
         "langchain/langgraphjs-api",
@@ -477,6 +480,7 @@ ARG foo
 ADD . /deps/unit_tests
 RUN cd /deps/unit_tests && npm i
 ENV LANGSERVE_GRAPHS='{"agent": "./graphs/agent.js:graph"}'
+ENV LANGGRAPH_UI='{"agent": "./graphs/agent.ui.jsx"}'
 WORKDIR /deps/unit_tests
 RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts"""
 

libs/langgraph/README.md

@@ -1,6 +1,6 @@
 # 🦜🕸️LangGraph
 
-![Version](https://img.shields.io/pypi/v/langgraph)
+[![Version](https://img.shields.io/pypi/v/langgraph.svg)](https://pypi.org/project/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/)

libs/langgraph/langgraph/func/__init__.py

@@ -36,23 +36,31 @@ from langgraph.types import _DC_KWARGS, RetryPolicy, StreamMode
 
 @overload
 def task(
-    *, name: Optional[str] = None, retry: Optional[RetryPolicy] = None
-) -> Callable[[Callable[P, T]], Callable[P, SyncAsyncFuture[T]]]: ...
+    *,
+    name: Optional[str] = None,
+    retry: Optional[RetryPolicy] = None,
+) -> Callable[
+    [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
+    Callable[P, SyncAsyncFuture[T]],
+]: ...
 
 
 @overload
 def task(
-    __func_or_none__: Callable[P, T],
+    __func_or_none__: Union[Callable[P, Awaitable[T]], Callable[P, T]],
 ) -> Callable[P, SyncAsyncFuture[T]]: ...
 
 
 def task(
-    __func_or_none__: Optional[Union[Callable[P, T], Callable[P, Awaitable[T]]]] = None,
+    __func_or_none__: Optional[Union[Callable[P, Awaitable[T]], Callable[P, T]]] = None,
     *,
     name: Optional[str] = None,
     retry: Optional[RetryPolicy] = None,
 ) -> Union[
-    Callable[[Callable[P, T]], Callable[P, SyncAsyncFuture[T]]],
+    Callable[
+        [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
+        Callable[P, SyncAsyncFuture[T]],
+    ],
     Callable[P, SyncAsyncFuture[T]],
 ]:
     """Define a LangGraph task using the `task` decorator.
@@ -345,7 +353,7 @@ class entrypoint:
         value: R
         """Value to return. A value will always be returned even if it is None."""
         save: S
-        """The value for the state for the next checkpoint. 
+        """The value for the state for the next checkpoint.
 
         A value will always be saved even if it is None.
         """

libs/langgraph/langgraph/graph/branch.py

@@ -0,0 +1,215 @@
+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

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 from collections import defaultdict
 from typing import (
@@ -6,15 +5,11 @@ from typing import (
     Awaitable,
     Callable,
     Hashable,
-    Literal,
     NamedTuple,
     Optional,
     Sequence,
     Union,
     cast,
-    get_args,
-    get_origin,
-    get_type_hints,
     overload,
 )
 
@@ -34,12 +29,12 @@ from langgraph.constants import (
     TAG_HIDDEN,
     Send,
 )
-from langgraph.errors import InvalidUpdateError
+from langgraph.graph.branch import Branch
 from langgraph.pregel import Channel, Pregel
 from langgraph.pregel.read import PregelNode
 from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
 from langgraph.types import All, Checkpointer
-from langgraph.utils.runnable import RunnableCallable, RunnableLike, coerce_to_runnable
+from langgraph.utils.runnable import RunnableLike, coerce_to_runnable
 
 logger = logging.getLogger(__name__)
 
@@ -50,95 +45,6 @@ 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] = {}
@@ -267,25 +173,7 @@ 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"
@@ -295,7 +183,7 @@ class Graph:
                 f"Branch with name `{path.name}` already exists for node " f"`{source}`"
             )
         # save it
-        self.branches[source][name] = Branch(path, path_map_, then)
+        self.branches[source][name] = Branch.from_path(path, path_map, then, False)
         return self
 
     def set_entry_point(self, key: str) -> Self:
@@ -584,7 +472,7 @@ class CompiledGraph(Pregel):
                 )
                 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/state.py

@@ -7,7 +7,9 @@ from inspect import isclass, isfunction, ismethod, signature
 from types import FunctionType
 from typing import (
     Any,
+    Awaitable,
     Callable,
+    Hashable,
     Literal,
     NamedTuple,
     Optional,
@@ -40,7 +42,14 @@ from langgraph.errors import (
     ParentCommand,
     create_error_message,
 )
-from langgraph.graph.graph import END, START, Branch, CompiledGraph, Graph, Send
+from langgraph.graph.branch import Branch
+from langgraph.graph.graph import (
+    END,
+    START,
+    CompiledGraph,
+    Graph,
+    Send,
+)
 from langgraph.managed.base import (
     ChannelKeyPlaceholder,
     ChannelTypePlaceholder,
@@ -461,6 +470,57 @@ 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]]],
@@ -566,6 +626,11 @@ 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,
@@ -675,7 +740,9 @@ class CompiledStateGraph(CompiledGraph):
             elif isinstance(input, Command):
                 if input.graph == Command.PARENT:
                     return None
-                return input._update_as_tuples()
+                return [
+                    (k, v) for k, v in input._update_as_tuples() if k in output_keys
+                ]
             elif (
                 isinstance(input, (list, tuple))
                 and input
@@ -686,7 +753,9 @@ class CompiledStateGraph(CompiledGraph):
                     if isinstance(i, Command):
                         if i.graph == Command.PARENT:
                             continue
-                        updates.extend(i._update_as_tuples())
+                        updates.extend(
+                            (k, v) for k, v in i._update_as_tuples() if k in output_keys
+                        )
                     else:
                         updates.extend(_get_updates(i) or ())
                 return updates
@@ -748,11 +817,7 @@ 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=(
-                    None
-                    if is_single_input or issubclass(input_schema, dict)
-                    else partial(_coerce_state, input_schema)
-                ),
+                mapper=_pick_mapper(list(input_values), input_schema),
                 writers=[
                     # publish to this channel and state keys
                     ChannelWrite(
@@ -822,12 +887,12 @@ class CompiledStateGraph(CompiledGraph):
                     config, cast(Sequence[Union[Send, ChannelWriteEntry]], writes)
                 )
 
-        # attach branch publisher
-        schema = (
+        schema = branch.input_schema or (
             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,
@@ -867,14 +932,34 @@ def _get_state_reader(
         select=select[0] if select == ["__root__"] else select,
         fresh=True,
         # coerce state dict to schema class (eg. pydantic model)
-        mapper=(
-            None
-            if state_keys == ["__root__"] or issubclass(schema, dict)
-            else partial(_coerce_state, schema)
-        ),
+        mapper=_pick_mapper(state_keys, schema),
     )
 
 
+def _pick_mapper(
+    state_keys: Sequence[str], schema: Type[Any]
+) -> Optional[Callable[[Any], Any]]:
+    if state_keys == ["__root__"]:
+        return None
+    if issubclass(schema, dict):
+        return None
+    if issubclass(schema, BaseModel):
+        return partial(_coerce_state_pydantic, schema)
+    if issubclass(schema, BaseModelV1):
+        return partial(_coerce_state_pydantic_v1, schema)
+    return partial(_coerce_state, schema)
+
+
+def _coerce_state_pydantic(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
+    return schema.model_construct(**input)
+
+
+def _coerce_state_pydantic_v1(
+    schema: Type[Any], input: dict[str, Any]
+) -> dict[str, Any]:
+    return schema.construct(**input)
+
+
 def _coerce_state(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
     return schema(**input)
 

libs/langgraph/langgraph/prebuilt/tool_executor.py

@@ -1,134 +0,0 @@
-from typing import Any, Callable, Sequence, Union
-
-from langchain_core.load.serializable import Serializable
-from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import BaseTool
-from langchain_core.tools import tool as create_tool
-
-from langgraph._api.deprecation import deprecated
-from langgraph.utils.runnable import RunnableCallable
-
-INVALID_TOOL_MSG_TEMPLATE = (
-    "{requested_tool_name} is not a valid tool, "
-    "try one of [{available_tool_names_str}]."
-)
-
-
-@deprecated("0.2.0", "langgraph.prebuilt.ToolNode", removal="0.3.0")
-class ToolInvocationInterface:
-    """Interface for invoking a tool.
-
-    Attributes:
-        tool (str): The name of the tool to invoke.
-        tool_input (Union[str, dict]): The input to pass to the tool.
-
-    """
-
-    tool: str
-    tool_input: Union[str, dict]
-
-
-@deprecated("0.2.0", "langgraph.prebuilt.ToolNode", removal="0.3.0")
-class ToolInvocation(Serializable):
-    """Information about how to invoke a tool.
-
-    Attributes:
-        tool (str): The name of the Tool to execute.
-        tool_input (Union[str, dict]): The input to pass in to the Tool.
-
-    Examples:
-        Basic usage:
-        ```pycon
-        >>> invocation = ToolInvocation(
-        ...    tool="search",
-        ...     tool_input="What is the capital of France?"
-        ... )
-        ```
-    """
-
-    tool: str
-    tool_input: Union[str, dict]
-
-
-@deprecated("0.2.0", "langgraph.prebuilt.ToolNode", removal="0.3.0")
-class ToolExecutor(RunnableCallable):
-    """Executes a tool invocation.
-
-    Args:
-        tools (Sequence[BaseTool]): A sequence of tools that can be invoked.
-        invalid_tool_msg_template (str, optional): The template for the error message
-            when an invalid tool is requested. Defaults to INVALID_TOOL_MSG_TEMPLATE.
-
-    Examples:
-        Basic usage:
-
-        ```pycon
-        >>> from langchain_core.tools import tool
-        >>> from langgraph.prebuilt.tool_executor import ToolExecutor, ToolInvocation
-        ...
-        ...
-        >>> @tool
-        ... def search(query: str) -> str:
-        ...     \"\"\"Search engine.\"\"\"
-        ...     return f"Searching for: {query}"
-        ...
-        ...
-        >>> tools = [search]
-        >>> executor = ToolExecutor(tools)
-        ...
-        >>> invocation = ToolInvocation(tool="search", tool_input="What is the capital of France?")
-        >>> result = executor.invoke(invocation)
-        >>> print(result)
-        "Searching for: What is the capital of France?"
-        ```
-        Handling invalid tool:
-
-        ```pycon
-        >>> invocation = ToolInvocation(
-        ...     tool="nonexistent", tool_input="What is the capital of France?"
-        ... )
-        >>> result = executor.invoke(invocation)
-        >>> print(result)
-        "nonexistent is not a valid tool, try one of [search]."
-        ```
-    """
-
-    def __init__(
-        self,
-        tools: Sequence[Union[BaseTool, Callable]],
-        *,
-        invalid_tool_msg_template: str = INVALID_TOOL_MSG_TEMPLATE,
-    ) -> None:
-        super().__init__(self._execute, afunc=self._aexecute, trace=False)
-        tools_ = [
-            tool if isinstance(tool, BaseTool) else create_tool(tool) for tool in tools
-        ]
-        self.tools = tools_
-        self.tool_map = {t.name: t for t in tools_}
-        self.invalid_tool_msg_template = invalid_tool_msg_template
-
-    def _execute(
-        self, tool_invocation: ToolInvocationInterface, config: RunnableConfig
-    ) -> Any:
-        if tool_invocation.tool not in self.tool_map:
-            return self.invalid_tool_msg_template.format(
-                requested_tool_name=tool_invocation.tool,
-                available_tool_names_str=", ".join([t.name for t in self.tools]),
-            )
-        else:
-            tool = self.tool_map[tool_invocation.tool]
-            output = tool.invoke(tool_invocation.tool_input, config)
-            return output
-
-    async def _aexecute(
-        self, tool_invocation: ToolInvocationInterface, config: RunnableConfig
-    ) -> Any:
-        if tool_invocation.tool not in self.tool_map:
-            return self.invalid_tool_msg_template.format(
-                requested_tool_name=tool_invocation.tool,
-                available_tool_names_str=", ".join([t.name for t in self.tools]),
-            )
-        else:
-            tool = self.tool_map[tool_invocation.tool]
-            output = await tool.ainvoke(tool_invocation.tool_input, config)
-            return output

libs/langgraph/langgraph/pregel/__init__.py

@@ -18,6 +18,7 @@ from typing import (
     Type,
     Union,
     cast,
+    get_type_hints,
     overload,
 )
 from uuid import UUID, uuid5
@@ -119,7 +120,7 @@ from langgraph.utils.config import (
     recast_checkpoint_ns,
 )
 from langgraph.utils.fields import get_enhanced_type_hints
-from langgraph.utils.pydantic import create_model
+from langgraph.utils.pydantic import create_model, is_supported_by_pydantic
 from langgraph.utils.queue import AsyncQueue, SyncQueue  # type: ignore[attr-defined]
 
 WriteValue = Union[Callable[[Input], Output], Any]
@@ -200,10 +201,42 @@ class Channel:
 class Pregel(PregelProtocol):
     """Pregel manages the runtime behavior for LangGraph applications.
 
+    ## Overview
+
+    Pregel combines [**actors**](https://en.wikipedia.org/wiki/Actor_model)
+    and **channels** into a single application.
+    **Actors** read data from channels and write data to channels.
+    Pregel organizes the execution of the application into multiple steps,
+    following the **Pregel Algorithm**/**Bulk Synchronous Parallel** model.
+
+    Each step consists of three phases:
+
+    - **Plan**: Determine which **actors** to execute in this step. For example,
+        in the first step, select the **actors** that subscribe to the special
+        **input** channels; in subsequent steps,
+        select the **actors** that subscribe to channels updated in the previous step.
+    - **Execution**: Execute all selected **actors** in parallel,
+        until all complete, or one fails, or a timeout is reached. During this
+        phase, channel updates are invisible to actors until the next step.
+    - **Update**: Update the channels with the values written by the **actors**
+        in this step.
+
+    Repeat until no **actors** are selected for execution, or a maximum number of
+    steps is reached.
+
+    ## Actors
+
+    An **actor** is a [PregelNode][langgraph.pregel.read.PregelNode].
+    It subscribes to channels, reads data from them, and writes data to them.
+    It can be thought of as an **actor** in the Pregel algorithm.
+    [PregelNodes][langgraph.pregel.read.PregelNode] implement LangChain's
+    Runnable interface.
+
     ## Channels
 
-    Channels are used to communicate between chains. Each channel has a value type,
-    an update type, and an update function – which takes a sequence of updates and
+    Channels are used to communicate between actors (PregelNodes).
+    Each channel has a value type, an update type, and an update function – which
+    takes a sequence of updates and
     modifies the stored value. Channels can be used to send data from one chain to
     another, or to send data from a chain to itself in a future step. LangGraph
     provides a number of built-in channels:
@@ -213,7 +246,7 @@ class Pregel(PregelProtocol):
     - `LastValue`: The default channel, stores the last value sent to the channel,
        useful for input and output values, or for sending data from one step to the next
     - `Topic`: A configurable PubSub Topic, useful for sending multiple values
-       between chains, or for accumulating output. Can be configured to deduplicate
+       between *actors*, or for accumulating output. Can be configured to deduplicate
        values, and/or to accumulate values over the course of multiple steps.
 
     ### Advanced channels: Context and BinaryOperatorAggregate
@@ -226,30 +259,202 @@ class Pregel(PregelProtocol):
        sent to the channel, useful for computing aggregates over multiple steps. eg.
       `total = BinaryOperatorAggregate(int, operator.add)`
 
-    ## Chains
+    ## Examples
 
-    Chains are LCEL Runnables which subscribe to one or more channels, and write to
-    one or more channels. Any valid LCEL expression can be used as a chain. Chains
-    can be combined into a Pregel application, which coordinates the execution of the
-    chains across multiple steps.
+    Most users will interact with Pregel via a
+    [StateGraph (Graph API)][langgraph.graph.StateGraph] or via an
+    [entrypoint (Functional API)][langgraph.func.entrypoint].
 
-    ## Pregel
+    However, for **advanced** use cases, Pregel can be used directly. If you're
+    not sure whether you need to use Pregel directly, then the answer is probably no
+    – you should use the Graph API or Functional API instead. These are higher-level
+    interfaces that will compile down to Pregel under the hood.
 
-    Pregel combines multiple chains (or actors) into a single application. It
-    coordinates the execution of the chains across multiple steps, following the
-    Pregel/Bulk Synchronous Parallel model. Each step consists of three phases:
+    Here are some examples to give you a sense of how it works:
 
-    - **Plan**: Determine which chains to execute in this step, ie. the chains that
-      subscribe to channels updated in the previous step (or, in the first step,
-      chains that subscribe to input channels)
-    - **Execution**: Execute those chains in parallel, until all complete, or one fails,
-      or a timeout is reached. Any channel updates are invisible to other
-      chains until the next step.
-     - **Update**: Update the channels with the values written by the
-      chains in this step.
+    Example: Single node application
+        ```python
+        from langgraph.channels import EphemeralValue
+        from langgraph.pregel import Pregel, Channel, ChannelWriteEntry
 
-    Repeat until no chains are planned for execution, or a maximum number of steps
-    is reached.
+        node1 = (
+            Channel.subscribe_to("a")
+            | (lambda x: x + x)
+            | Channel.write_to("b")
+        )
+
+        app = Pregel(
+            nodes={"node1": node1},
+            channels={
+                "a": EphemeralValue(str),
+                "b": EphemeralValue(str),
+            },
+            input_channels=["a"],
+            output_channels=["b"],
+        )
+
+        app.invoke({"a": "foo"})
+        ```
+
+        ```con
+        {'b': 'foofoo'}
+        ```
+
+    Example: Using multiple nodes and multiple output channels
+        ```python
+        from langgraph.channels import LastValue, EphemeralValue
+        from langgraph.pregel import Pregel, Channel, ChannelWriteEntry
+
+        node1 = (
+            Channel.subscribe_to("a")
+            | (lambda x: x + x)
+            | Channel.write_to("b")
+        )
+
+        node2 = (
+            Channel.subscribe_to("b")
+            | (lambda x: x + x)
+            | Channel.write_to("c")
+        )
+
+
+        app = Pregel(
+            nodes={"node1": node1, "node2": node2},
+            channels={
+                "a": EphemeralValue(str),
+                "b": LastValue(str),
+                "c": EphemeralValue(str),
+            },
+            input_channels=["a"],
+            output_channels=["b", "c"],
+        )
+
+        app.invoke({"a": "foo"})
+        ```
+
+        ```con
+        {'b': 'foofoo', 'c': 'foofoofoofoo'}
+        ```
+
+    Example: Using a Topic channel
+        ```python
+        from langgraph.channels import LastValue, EphemeralValue, Topic
+        from langgraph.pregel import Pregel, Channel, ChannelWriteEntry
+
+        node1 = (
+            Channel.subscribe_to("a")
+            | (lambda x: x + x)
+            | {
+                "b": Channel.write_to("b"),
+                "c": Channel.write_to("c")
+            }
+        )
+
+        node2 = (
+            Channel.subscribe_to("b")
+            | (lambda x: x + x)
+            | {
+                "c": Channel.write_to("c"),
+            }
+        )
+
+
+        app = Pregel(
+            nodes={"node1": node1, "node2": node2},
+            channels={
+                "a": EphemeralValue(str),
+                "b": EphemeralValue(str),
+                "c": Topic(str, accumulate=True),
+            },
+            input_channels=["a"],
+            output_channels=["c"],
+        )
+
+        app.invoke({"a": "foo"})
+        ```
+
+        ```pycon
+        {'c': ['foofoo', 'foofoofoofoo']}
+        ```
+
+    Example: Using a BinaryOperatorAggregate channel
+        ```python
+        from langgraph.channels import EphemeralValue, BinaryOperatorAggregate
+        from langgraph.pregel import Pregel, Channel
+
+
+        node1 = (
+            Channel.subscribe_to("a")
+            | (lambda x: x + x)
+            | {
+                "b": Channel.write_to("b"),
+                "c": Channel.write_to("c")
+            }
+        )
+
+        node2 = (
+            Channel.subscribe_to("b")
+            | (lambda x: x + x)
+            | {
+                "c": Channel.write_to("c"),
+            }
+        )
+
+
+        def reducer(current, update):
+            if current:
+                return current + " | " + "update"
+            else:
+                return update
+
+        app = Pregel(
+            nodes={"node1": node1, "node2": node2},
+            channels={
+                "a": EphemeralValue(str),
+                "b": EphemeralValue(str),
+                "c": BinaryOperatorAggregate(str, operator=reducer),
+            },
+            input_channels=["a"],
+            output_channels=["c"]
+        )
+
+        app.invoke({"a": "foo"})
+        ```
+
+        ```con
+        {'c': 'foofoo | foofoofoofoo'}
+        ```
+
+    Example: Introducing a cycle
+        This example demonstrates how to introduce a cycle in the graph, by having
+        a chain write to a channel it subscribes to. Execution will continue
+        until a None value is written to the channel.
+
+        ```python
+        from langgraph.channels import EphemeralValue
+        from langgraph.pregel import Pregel, Channel, ChannelWrite, ChannelWriteEntry
+
+        example_node = (
+            Channel.subscribe_to("value")
+            | (lambda x: x + x if len(x) < 10 else None)
+            | ChannelWrite(writes=[ChannelWriteEntry(channel="value", skip_none=True)])
+        )
+
+        app = Pregel(
+            nodes={"example_node": example_node},
+            channels={
+                "value": EphemeralValue(str),
+            },
+            input_channels=["value"],
+            output_channels=["value"]
+        )
+
+        app.invoke({"value": "a"})
+        ```
+
+        ```con
+        {'value': 'aaaaaaaaaaaaaaaa'}
+        ```
     """
 
     nodes: dict[str, PregelNode]
@@ -291,6 +496,8 @@ class Pregel(PregelProtocol):
 
     config_type: Optional[Type[Any]] = None
 
+    input_model: Optional[Type[BaseModel]] = None
+
     config: Optional[RunnableConfig] = None
 
     name: str = "LangGraph"
@@ -314,6 +521,7 @@ 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:
@@ -332,6 +540,7 @@ 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:
@@ -405,6 +614,36 @@ class Pregel(PregelProtocol):
             ]
         ]
 
+    def config_schema(
+        self, *, include: Optional[Sequence[str]] = None
+    ) -> Type[BaseModel]:
+        # If the config type is not set explicitly, we will try to infer it.
+        # If the config type is provided, but isn't directly supported by pydantic
+        # (e.g., vanilla python class), we will also delegate to the parent class,
+        # which handles cases where Pydantic doesn't support the type.
+        if self.config_type is None or not is_supported_by_pydantic(self.config_type):
+            return super().config_schema(include=include)
+
+        include = include or []
+        fields = {
+            "configurable": (self.config_type, None),
+            **{
+                field_name: (field_type, None)
+                for field_name, field_type in get_type_hints(RunnableConfig).items()
+                if field_name in [i for i in include if i != "configurable"]
+            },
+        }
+        return create_model(self.get_name("Config"), field_definitions=fields)
+
+    def get_config_jsonschema(
+        self, *, include: Optional[Sequence[str]] = None
+    ) -> Dict[str, Any]:
+        schema = self.config_schema(include=include)
+        if hasattr(schema, "model_json_schema"):
+            return schema.model_json_schema()
+        else:
+            return schema.schema()
+
     @property
     def InputType(self) -> Any:
         if isinstance(self.input_channels, str):
@@ -415,6 +654,8 @@ 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)
@@ -430,7 +671,7 @@ class Pregel(PregelProtocol):
 
     def get_input_jsonschema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Dict[All, Any]:
+    ) -> Dict[str, Any]:
         schema = self.get_input_schema(config)
         if hasattr(schema, "model_json_schema"):
             return schema.model_json_schema()
@@ -462,7 +703,7 @@ class Pregel(PregelProtocol):
 
     def get_output_jsonschema(
         self, config: Optional[RunnableConfig] = None
-    ) -> Dict[All, Any]:
+    ) -> Dict[str, Any]:
         schema = self.get_output_schema(config)
         if hasattr(schema, "model_json_schema"):
             return schema.model_json_schema()
@@ -767,6 +1008,12 @@ class Pregel(PregelProtocol):
                 raise ValueError(f"Subgraph {recast} not found")
 
         config = merge_configs(self.config, config) if self.config else config
+        if self.checkpointer is True:
+            ns = cast(str, config[CONF][CONFIG_KEY_CHECKPOINT_NS])
+            config = merge_configs(
+                config, {CONF: {CONFIG_KEY_CHECKPOINT_NS: recast_checkpoint_ns(ns)}}
+            )
+
         saved = checkpointer.get_tuple(config)
         return self._prepare_state_snapshot(
             config,
@@ -800,6 +1047,12 @@ class Pregel(PregelProtocol):
                 raise ValueError(f"Subgraph {recast} not found")
 
         config = merge_configs(self.config, config) if self.config else config
+        if self.checkpointer is True:
+            ns = cast(str, config[CONF][CONFIG_KEY_CHECKPOINT_NS])
+            config = merge_configs(
+                config, {CONF: {CONFIG_KEY_CHECKPOINT_NS: recast_checkpoint_ns(ns)}}
+            )
+
         saved = await checkpointer.aget_tuple(config)
         return await self._aprepare_state_snapshot(
             config,
@@ -1707,9 +1960,7 @@ class Pregel(PregelProtocol):
             # set up subgraph checkpointing
             if self.checkpointer is True:
                 ns = cast(str, config[CONF][CONFIG_KEY_CHECKPOINT_NS])
-                config[CONF][CONFIG_KEY_CHECKPOINT_NS] = NS_SEP.join(
-                    part.split(NS_END)[0] for part in ns.split(NS_SEP)
-                )
+                config[CONF][CONFIG_KEY_CHECKPOINT_NS] = recast_checkpoint_ns(ns)
             # set up messages stream mode
             if "messages" in stream_modes:
                 run_manager.inheritable_handlers.append(
@@ -1722,6 +1973,7 @@ class Pregel(PregelProtocol):
                 )
             with SyncPregelLoop(
                 input,
+                input_model=self.input_model,
                 stream=StreamProtocol(stream.put, stream_modes),
                 config=config,
                 store=store,
@@ -1997,9 +2249,7 @@ class Pregel(PregelProtocol):
             # set up subgraph checkpointing
             if self.checkpointer is True:
                 ns = cast(str, config[CONF][CONFIG_KEY_CHECKPOINT_NS])
-                config[CONF][CONFIG_KEY_CHECKPOINT_NS] = NS_SEP.join(
-                    part.split(NS_END)[0] for part in ns.split(NS_SEP)
-                )
+                config[CONF][CONFIG_KEY_CHECKPOINT_NS] = recast_checkpoint_ns(ns)
             # set up messages stream mode
             if "messages" in stream_modes:
                 run_manager.inheritable_handlers.append(
@@ -2014,6 +2264,7 @@ 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/loop.py

@@ -2,7 +2,6 @@ import asyncio
 import concurrent.futures
 from collections import defaultdict, deque
 from contextlib import AsyncExitStack, ExitStack
-from dataclasses import replace
 from inspect import signature
 from types import TracebackType
 from typing import (
@@ -24,6 +23,7 @@ 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
@@ -55,6 +55,7 @@ from langgraph.constants import (
     ERROR,
     INPUT,
     INTERRUPT,
+    MISSING,
     NS_SEP,
     NULL_TASK_ID,
     PUSH,
@@ -67,7 +68,6 @@ from langgraph.errors import (
     EmptyInputError,
     GraphDelegate,
     GraphInterrupt,
-    ParentCommand,
 )
 from langgraph.managed.base import (
     ManagedValueMapping,
@@ -126,6 +126,7 @@ P = ParamSpec("P")
 
 INPUT_DONE = object()
 INPUT_RESUMING = object()
+INPUT_SHOULD_VALIDATE = object()
 SPECIAL_CHANNELS = (ERROR, INTERRUPT, SCHEDULED)
 
 
@@ -140,6 +141,7 @@ 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]]
@@ -203,6 +205,7 @@ 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__(
@@ -213,6 +216,7 @@ class PregelLoop(LoopProtocol):
             store=store,
         )
         self.input = input
+        self.input_model = input_model
         self.checkpointer = checkpointer
         self.nodes = nodes
         self.specs = specs
@@ -396,13 +400,14 @@ 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):
+        if self.input not in (INPUT_DONE, INPUT_RESUMING, INPUT_SHOULD_VALIDATE):
             self._first(input_keys=input_keys)
         elif self.to_interrupt:
             # if we need to interrupt, do so
             self.status = "interrupt_before"
             raise GraphInterrupt()
         elif all(task.writes for task in self.tasks.values()):
+            # finish superstep
             writes = [w for t in self.tasks.values() for w in t.writes]
             # debug flag
             if self.debug:
@@ -425,6 +430,13 @@ 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
@@ -451,6 +463,9 @@ class PregelLoop(LoopProtocol):
             ):
                 self.status = "interrupt_after"
                 raise GraphInterrupt()
+
+            # unset resuming flag
+            self.config[CONF].pop(CONFIG_KEY_RESUMING, None)
         else:
             return False
 
@@ -562,7 +577,13 @@ class PregelLoop(LoopProtocol):
         is_resuming = bool(self.checkpoint["channel_versions"]) and bool(
             configurable.get(
                 CONFIG_KEY_RESUMING,
-                self.input is None or isinstance(self.input, Command),
+                self.input is None
+                or isinstance(self.input, Command)
+                or (
+                    not self.is_nested
+                    and self.config.get("metadata", {}).get("run_id")
+                    == self.checkpoint_metadata.get("run_id", MISSING)
+                ),
             )
         )
 
@@ -613,6 +634,8 @@ 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?
@@ -653,10 +676,19 @@ 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}")
-        # done with input
-        self.input = INPUT_RESUMING if is_resuming else INPUT_DONE
+        else:
+            self.input = INPUT_DONE
         # update config
         if not self.is_nested:
             self.config = patch_configurable(
@@ -738,15 +770,6 @@ class PregelLoop(LoopProtocol):
         exc_value: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> Optional[bool]:
-        # add current state to parent command
-        if isinstance(exc_value, ParentCommand):
-            cmd = exc_value.args[0]
-            state = (
-                [(self.output_keys, read_channels(self.channels, self.output_keys))]
-                if isinstance(self.output_keys, str)
-                else list(read_channels(self.channels, self.output_keys).items())
-            )
-            exc_value.args = (replace(cmd, update=[*state, *cmd._update_as_tuples()]),)
         # suppress interrupt
         suppress = isinstance(exc_value, GraphInterrupt) and not self.is_nested
         if suppress:
@@ -840,10 +863,12 @@ 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,
@@ -888,7 +913,11 @@ class SyncPregelLoop(PregelLoop, ContextManager):
             )
 
     def _update_mv(self, key: str, values: Sequence[Any]) -> None:
-        return self.submit(cast(WritableManagedValue, self.managed[key]).update, values)
+        managed_value = self.managed.get(key)
+        if managed_value is None:
+            return
+
+        return self.submit(cast(WritableManagedValue, managed_value).update, values)
 
     # context manager
 
@@ -975,10 +1004,12 @@ 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,
@@ -1023,9 +1054,11 @@ class AsyncPregelLoop(PregelLoop, AsyncContextManager):
             )
 
     def _update_mv(self, key: str, values: Sequence[Any]) -> None:
-        return self.submit(
-            cast(WritableManagedValue, self.managed[key]).aupdate, values
-        )
+        managed_value = self.managed.get(key)
+        if managed_value is None:
+            return
+
+        return self.submit(cast(WritableManagedValue, managed_value).aupdate, values)
 
     # context manager
 

libs/langgraph/langgraph/pregel/messages.py

@@ -127,6 +127,16 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
                 tuple(cast(str, metadata["langgraph_checkpoint_ns"]).split(NS_SEP)),
                 metadata,
             )
+            if isinstance(inputs, dict):
+                for key, value in inputs.items():
+                    if isinstance(value, BaseMessage):
+                        if value.id is not None:
+                            self.seen.add(value.id)
+                    elif isinstance(value, Sequence) and not isinstance(value, str):
+                        for item in value:
+                            if isinstance(item, BaseMessage):
+                                if item.id is not None:
+                                    self.seen.add(item.id)
 
     def on_chain_end(
         self,

libs/langgraph/langgraph/pregel/validate.py

@@ -32,11 +32,17 @@ def validate_graph(
 
     for chan in subscribed_channels:
         if chan not in channels:
-            raise ValueError(f"Subscribed channel '{chan}' not in 'channels'")
+            raise ValueError(
+                f"Subscribed channel '{chan}' not "
+                f"in known channels: '{repr(sorted(channels))[:100]}'"
+            )
 
     if isinstance(input_channels, str):
         if input_channels not in channels:
-            raise ValueError(f"Input channel '{input_channels}' not in 'channels'")
+            raise ValueError(
+                f"Input channel '{input_channels}' not "
+                f"in known channels: '{repr(sorted(channels))[:100]}'"
+            )
         if input_channels not in subscribed_channels:
             raise ValueError(
                 f"Input channel {input_channels} is not subscribed to by any node"
@@ -44,10 +50,13 @@ def validate_graph(
     else:
         for chan in input_channels:
             if chan not in channels:
-                raise ValueError(f"Input channel '{chan}' not in 'channels'")
+                raise ValueError(
+                    f"Input channel '{chan}' not in '{repr(sorted(channels))[:100]}'"
+                )
         if all(chan not in subscribed_channels for chan in input_channels):
             raise ValueError(
-                f"None of the input channels {input_channels} are subscribed to by any node"
+                f"None of the input channels {input_channels} "
+                f"are subscribed to by any node"
             )
 
     all_output_channels = set[str]()
@@ -62,7 +71,10 @@ def validate_graph(
 
     for chan in all_output_channels:
         if chan not in channels:
-            raise ValueError(f"Output channel '{chan}' not in 'channels'")
+            raise ValueError(
+                f"Output channel '{chan}' not "
+                f"in known channels: '{repr(sorted(channels))[:100]}'"
+            )
 
     if interrupt_after_nodes != "*":
         for n in interrupt_after_nodes:

libs/langgraph/langgraph/utils/pydantic.py

@@ -1,5 +1,9 @@
+import sys
+import typing
+from dataclasses import is_dataclass
 from typing import Any, Dict, Optional, Union
 
+import typing_extensions
 from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
 
@@ -35,3 +39,31 @@ def create_model(
             v1_kwargs["__root__"] = root
 
         return create_model(model_name, **v1_kwargs, **(field_definitions or {}))
+
+
+def is_supported_by_pydantic(type_: Any) -> bool:
+    """Check if a given "complex" type is supported by pydantic.
+
+    This will return False for primitive types like int, str, etc.
+
+    The check is meant for container types like dataclasses, TypedDicts, etc.
+    """
+    if is_dataclass(type_):
+        return True
+
+    # Pydantic does not support mixing .v1 and root namespaces, so
+    # we only check for BaseModel (not pydantic.v1.BaseModel).
+    if isinstance(type_, type) and issubclass(type_, BaseModel):
+        return True
+
+    if hasattr(type_, "__orig_bases__"):
+        for base in type_.__orig_bases__:
+            if base is typing_extensions.TypedDict:
+                return True
+            elif base is typing.TypedDict:  # noqa: TID251
+                # ignoring TID251 since it's OK to use typing.TypedDict in this case.
+                # Pydantic supports typing.TypedDict from Python 3.12
+                # For older versions, only typing_extensions.TypedDict is supported.
+                if sys.version_info >= (3, 12):
+                    return True
+    return False

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.30"
+version = "0.3.44"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["main", "dev"]
 files = [
-    {file = "langchain_core-0.3.30-py3-none-any.whl", hash = "sha256:0a4c4e02fac5968b67fbb0142c00c2b976c97e45fce62c7ac9eb1636a6926493"},
-    {file = "langchain_core-0.3.30.tar.gz", hash = "sha256:0f1281b4416977df43baf366633ad18e96c5dcaaeae6fcb8a799f9889c853243"},
+    {file = "langchain_core-0.3.44-py3-none-any.whl", hash = "sha256:d989ce8bd62f1d07765acd575e6ec1254aec0cf7775aaea39fe4af8102377459"},
+    {file = "langchain_core-0.3.44.tar.gz", hash = "sha256:7c0a01e78360f007cbca448178fe7e032404068e6431dbe8ce905f84febbdfa5"},
 ]
 
 [package.dependencies]
 jsonpatch = ">=1.33,<2.0"
-langsmith = ">=0.1.125,<0.3"
+langsmith = ">=0.1.125,<0.4"
 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.10"
+version = "2.0.18"
 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.12"
+version = "2.0.16"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -1375,7 +1375,7 @@ files = []
 develop = true
 
 [package.dependencies]
-langgraph-checkpoint = "^2.0.10"
+langgraph-checkpoint = "^2.0.15"
 orjson = ">=3.10.1"
 psycopg = "^3.2.0"
 psycopg-pool = "^3.2.0"
@@ -1386,7 +1386,7 @@ url = "../checkpoint-postgres"
 
 [[package]]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.3"
+version = "2.0.6"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0"
@@ -1395,16 +1395,34 @@ files = []
 develop = true
 
 [package.dependencies]
-aiosqlite = "^0.20.0"
-langgraph-checkpoint = "^2.0.10"
+aiosqlite = ">=0.20,<0.22"
+langgraph-checkpoint = "^2.0.15"
 
 [package.source]
 type = "directory"
 url = "../checkpoint-sqlite"
 
+[[package]]
+name = "langgraph-prebuilt"
+version = "0.1.2"
+description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
+optional = false
+python-versions = "^3.9.0,<4.0"
+groups = ["main", "dev"]
+files = []
+develop = true
+
+[package.dependencies]
+langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
+langgraph-checkpoint = "^2.0.10"
+
+[package.source]
+type = "directory"
+url = "../prebuilt"
+
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.51"
+version = "0.1.55"
 description = "SDK for interacting with LangGraph API"
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -3491,4 +3509,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.9.0,<4.0"
-content-hash = "caf943b02b6913c05d15c37fda6d216669f789e2a059b7e8e2490b2bdcd23e0e"
+content-hash = "eb85f0bcc0e8a715ef38afb58cf888f7c2ee8579ea6ed94900244365f24cddd9"

libs/langgraph/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph"
-version = "0.2.74"
+version = "0.3.7"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 license = "MIT"
@@ -9,9 +9,10 @@ repository = "https://www.github.com/langchain-ai/langgraph"
 
 [tool.poetry.dependencies]
 python = ">=3.9.0,<4.0"
-langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
+langchain-core = ">=0.1,<0.4"
 langgraph-checkpoint = "^2.0.10"
 langgraph-sdk = "^0.1.42"
+langgraph-prebuilt = ">=0.1.1,<0.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.2"
@@ -26,6 +27,7 @@ ruff = "^0.6.2"
 jupyter = "^1.0.0"
 pytest-xdist = {extras = ["psutil"], version = "^3.6.1"}
 pytest-repeat = "^0.9.3"
+langgraph-prebuilt = {path = "../prebuilt", develop = true}
 langgraph-checkpoint = {path = "../checkpoint", develop = true}
 langgraph-checkpoint-sqlite = {path = "../checkpoint-sqlite", develop = true}
 langgraph-checkpoint-postgres = {path = "../checkpoint-postgres", develop = true}

libs/langgraph/tests/__snapshots__/test_large_cases.ambr

@@ -3116,8 +3116,6 @@
   	__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__;
@@ -3126,6 +3124,8 @@
   	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
@@ -3141,8 +3141,6 @@
   	__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__;
@@ -3151,6 +3149,8 @@
   	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
@@ -3166,8 +3166,6 @@
   	__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__;
@@ -3176,6 +3174,8 @@
   	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
@@ -3191,8 +3191,6 @@
   	__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__;
@@ -3201,6 +3199,8 @@
   	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
@@ -3216,8 +3216,6 @@
   	__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__;
@@ -3226,6 +3224,8 @@
   	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
@@ -3241,8 +3241,6 @@
   	__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__;
@@ -3251,6 +3249,8 @@
   	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_large_cases_async.ambr

@@ -6,8 +6,6 @@
   	__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__;
@@ -16,6 +14,8 @@
   	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,8 +31,6 @@
   	__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__;
@@ -41,6 +39,8 @@
   	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,8 +56,6 @@
   	__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__;
@@ -66,6 +64,8 @@
   	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,8 +81,6 @@
   	__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__;
@@ -91,6 +89,8 @@
   	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,8 +106,6 @@
   	__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__;
@@ -116,6 +114,8 @@
   	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,8 +131,6 @@
   	__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__;
@@ -141,6 +139,8 @@
   	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

@@ -1217,6 +1217,426 @@
     'type': 'object',
   })
 # ---
+# name: test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic_input[memory]
+  '''
+  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_pydantic_input[memory].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_pydantic_input[memory].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[postgres]
+  '''
+  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_pydantic_input[postgres].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_pydantic_input[postgres].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[postgres_pipe]
+  '''
+  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_pydantic_input[postgres_pipe].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_pydantic_input[postgres_pipe].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[postgres_pool]
+  '''
+  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_pydantic_input[postgres_pool].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_pydantic_input[postgres_pool].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[postgres_shallow]
+  '''
+  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_pydantic_input[postgres_shallow].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_pydantic_input[postgres_shallow].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[sqlite]
+  '''
+  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_pydantic_input[sqlite].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_pydantic_input[sqlite].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_via_branch[memory]
   '''
   graph TD;
@@ -1302,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
@@ -1332,12 +1752,14 @@
   %%{init: {'flowchart': {'curve': 'linear'}}}%%
   graph TD;
   	__start__([<p>__start__</p>]):::first
-  	inner(inner)
   	side(side)
   	__end__([<p>__end__</p>]):::last
-  	__start__ --> inner;
-  	inner --> side;
+  	__start__ --> inner_up;
+  	inner_up --> 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
@@ -1475,10 +1897,6 @@
   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;
@@ -1488,6 +1906,10 @@
   	__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;
@@ -1528,7 +1950,7 @@
   '''
 # ---
 # name: test_state_graph_w_config_inherited_state_keys
-  '{"$defs": {"Configurable": {"properties": {"tools": {"default": null, "items": {"type": "string"}, "title": "Tools", "type": "array"}}, "title": "Configurable", "type": "object"}}, "properties": {"configurable": {"$ref": "#/$defs/Configurable", "default": null}}, "title": "LangGraphConfig", "type": "object"}'
+  '{"$defs": {"Config": {"properties": {"tools": {"items": {"type": "string"}, "title": "Tools", "type": "array"}}, "title": "Config", "type": "object"}}, "properties": {"configurable": {"$ref": "#/$defs/Config", "default": null}}, "title": "LangGraphConfig", "type": "object"}'
 # ---
 # name: test_state_graph_w_config_inherited_state_keys.1
   '{"$defs": {"AgentAction": {"description": "Represents a request to execute an action by an agent.\\n\\nThe action consists of the name of the tool to execute and the input to pass\\nto the tool. The log is used to pass along extra information about the action.", "properties": {"tool": {"title": "Tool", "type": "string"}, "tool_input": {"anyOf": [{"type": "string"}, {"type": "object"}], "title": "Tool Input"}, "log": {"title": "Log", "type": "string"}, "type": {"const": "AgentAction", "default": "AgentAction", "enum": ["AgentAction"], "title": "Type", "type": "string"}}, "required": ["tool", "tool_input", "log"], "title": "AgentAction", "type": "object"}, "AgentFinish": {"description": "Final return value of an ActionAgent.\\n\\nAgents return an AgentFinish when they have reached a stopping condition.", "properties": {"return_values": {"title": "Return Values", "type": "object"}, "log": {"title": "Log", "type": "string"}, "type": {"const": "AgentFinish", "default": "AgentFinish", "enum": ["AgentFinish"], "title": "Type", "type": "string"}}, "required": ["return_values", "log"], "title": "AgentFinish", "type": "object"}}, "properties": {"input": {"title": "Input", "type": "string"}, "agent_outcome": {"anyOf": [{"$ref": "#/$defs/AgentAction"}, {"$ref": "#/$defs/AgentFinish"}, {"type": "null"}], "default": null, "title": "Agent Outcome"}, "intermediate_steps": {"default": null, "items": {"maxItems": 2, "minItems": 2, "prefixItems": [{"$ref": "#/$defs/AgentAction"}, {"type": "string"}], "type": "array"}, "title": "Intermediate Steps", "type": "array"}}, "required": ["input"], "title": "LangGraphInput", "type": "object"}'
@@ -1542,24 +1964,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;
@@ -1578,16 +2000,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/test_large_cases.py

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

libs/langgraph/tests/test_pregel.py

@@ -10,7 +10,7 @@ import warnings
 from collections import Counter, deque
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from random import randrange
 from typing import (
     Annotated,
@@ -275,6 +275,61 @@ def test_checkpoint_errors() -> None:
         graph.invoke("", {"configurable": {"thread_id": "thread-1"}})
 
 
+def test_config_json_schema() -> None:
+    """Test that config json schema is generated properly."""
+    chain = Channel.subscribe_to("input") | Channel.write_to("output")
+
+    @dataclass
+    class Foo:
+        x: int
+        y: str = field(default="foo")
+
+    app = Pregel(
+        nodes={
+            "one": chain,
+        },
+        channels={
+            "ephemeral": EphemeralValue(Any),
+            "input": LastValue(int),
+            "output": LastValue(int),
+        },
+        input_channels=["input", "ephemeral"],
+        output_channels="output",
+        config_type=Foo,
+    )
+
+    assert app.get_config_jsonschema() == {
+        "$defs": {
+            "Foo": {
+                "properties": {
+                    "x": {
+                        "title": "X",
+                        "type": "integer",
+                    },
+                    "y": {
+                        "default": "foo",
+                        "title": "Y",
+                        "type": "string",
+                    },
+                },
+                "required": [
+                    "x",
+                ],
+                "title": "Foo",
+                "type": "object",
+            },
+        },
+        "properties": {
+            "configurable": {
+                "$ref": "#/$defs/Foo",
+                "default": None,
+            },
+        },
+        "title": "LangGraphConfig",
+        "type": "object",
+    }
+
+
 def test_node_schemas_custom_output() -> None:
     class State(TypedDict):
         hello: str
@@ -1444,7 +1499,7 @@ def test_imp_task(request: pytest.FixtureRequest, checkpointer_name: str) -> Non
     checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
     mapper_calls = 0
 
-    class Config:
+    class Configurable:
         model: str
 
     @task()
@@ -1454,7 +1509,7 @@ def test_imp_task(request: pytest.FixtureRequest, checkpointer_name: str) -> Non
         time.sleep(input / 100)
         return str(input) * 2
 
-    @entrypoint(checkpointer=checkpointer, config_schema=Config)
+    @entrypoint(checkpointer=checkpointer, config_schema=Configurable)
     def graph(input: list[int]) -> list[str]:
         futures = [mapper(i) for i in input]
         mapped = [f.result() for f in futures]
@@ -2839,6 +2894,139 @@ def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic2(
         }
 
 
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_in_one_fan_out_state_graph_waiting_edge_custom_state_class_pydantic_input(
+    snapshot: SnapshotAssertion,
+    mocker: MockerFixture,
+    request: pytest.FixtureRequest,
+    checkpointer_name: str,
+) -> None:
+    from pydantic import BaseModel
+
+    checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+
+    def sorted_add(
+        x: list[str], y: Union[list[str], list[tuple[str, str]]]
+    ) -> list[str]:
+        if isinstance(y[0], tuple):
+            for rem, _ in y:
+                x.remove(rem)
+            y = [t[1] for t in y]
+        return sorted(operator.add(x, y))
+
+    class InnerObject(BaseModel):
+        yo: int
+
+    class QueryModel(BaseModel):
+        query: str
+
+    class State(QueryModel):
+        inner: InnerObject
+        answer: Optional[str] = None
+        docs: Annotated[list[str], sorted_add]
+
+    class StateUpdate(BaseModel):
+        query: Optional[str] = None
+        answer: Optional[str] = None
+        docs: Optional[list[str]] = None
+
+    class Input(QueryModel):
+        inner: InnerObject
+
+    class Output(BaseModel):
+        answer: str
+        docs: list[str]
+
+    def rewrite_query(data: State) -> State:
+        return {"query": f"query: {data.query}"}
+
+    def analyzer_one(data: State) -> State:
+        return StateUpdate(query=f"analyzed: {data.query}")
+
+    def retriever_one(data: State) -> State:
+        return {"docs": ["doc1", "doc2"]}
+
+    def retriever_two(data: State) -> State:
+        time.sleep(0.1)
+        return {"docs": ["doc3", "doc4"]}
+
+    def qa(data: State) -> State:
+        return {"answer": ",".join(data.docs)}
+
+    def decider(data: State) -> str:
+        assert isinstance(data, State)
+        return "retriever_two"
+
+    workflow = StateGraph(State, input=Input, output=Output)
+
+    workflow.add_node("rewrite_query", rewrite_query)
+    workflow.add_node("analyzer_one", analyzer_one)
+    workflow.add_node("retriever_one", retriever_one)
+    workflow.add_node("retriever_two", retriever_two)
+    workflow.add_node("qa", qa)
+
+    workflow.set_entry_point("rewrite_query")
+    workflow.add_edge("rewrite_query", "analyzer_one")
+    workflow.add_edge("analyzer_one", "retriever_one")
+    workflow.add_conditional_edges(
+        "rewrite_query", decider, {"retriever_two": "retriever_two"}
+    )
+    workflow.add_edge(["retriever_one", "retriever_two"], "qa")
+    workflow.set_finish_point("qa")
+
+    app = workflow.compile()
+
+    assert app.invoke(
+        Input(query="what is weather in sf", inner=InnerObject(yo=1))
+    ) == {
+        "docs": ["doc1", "doc2", "doc3", "doc4"],
+        "answer": "doc1,doc2,doc3,doc4",
+    }
+
+    assert [
+        *app.stream(Input(query="what is weather in sf", inner=InnerObject(yo=1)))
+    ] == [
+        {"rewrite_query": {"query": "query: what is weather in sf"}},
+        {"analyzer_one": {"query": "analyzed: query: what is weather in sf"}},
+        {"retriever_two": {"docs": ["doc3", "doc4"]}},
+        {"retriever_one": {"docs": ["doc1", "doc2"]}},
+        {"qa": {"answer": "doc1,doc2,doc3,doc4"}},
+    ]
+
+    app_w_interrupt = workflow.compile(
+        checkpointer=checkpointer,
+        interrupt_after=["retriever_one"],
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    assert [
+        c
+        for c in app_w_interrupt.stream(
+            Input(query="what is weather in sf", inner=InnerObject(yo=1)), config
+        )
+    ] == [
+        {"rewrite_query": {"query": "query: what is weather in sf"}},
+        {"analyzer_one": {"query": "analyzed: query: what is weather in sf"}},
+        {"retriever_two": {"docs": ["doc3", "doc4"]}},
+        {"retriever_one": {"docs": ["doc1", "doc2"]}},
+        {"__interrupt__": ()},
+    ]
+
+    assert [c for c in app_w_interrupt.stream(None, config)] == [
+        {"qa": {"answer": "doc1,doc2,doc3,doc4"}},
+    ]
+
+    assert app_w_interrupt.update_state(
+        config, {"docs": ["doc5"]}, as_node="rewrite_query"
+    ) == {
+        "configurable": {
+            "thread_id": "1",
+            "checkpoint_id": AnyStr(),
+            "checkpoint_ns": "",
+        }
+    }
+
+
 @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
@@ -2905,14 +3093,24 @@ def test_in_one_fan_out_state_graph_waiting_edge_plus_regular(
         "answer": "doc1,doc2,doc3,doc4",
     }
 
-    assert [*app.stream({"query": "what is weather in sf"})] == [
-        {"rewrite_query": {"query": "query: what is weather in sf"}},
-        {"qa": {"answer": ""}},
-        {"analyzer_one": {"query": "analyzed: query: what is weather in sf"}},
-        {"retriever_two": {"docs": ["doc3", "doc4"]}},
-        {"retriever_one": {"docs": ["doc1", "doc2"]}},
-        {"qa": {"answer": "doc1,doc2,doc3,doc4"}},
-    ]
+    assert [*app.stream({"query": "what is weather in sf"})] in (
+        [
+            {"rewrite_query": {"query": "query: what is weather in sf"}},
+            {"qa": {"answer": ""}},
+            {"analyzer_one": {"query": "analyzed: query: what is weather in sf"}},
+            {"retriever_two": {"docs": ["doc3", "doc4"]}},
+            {"retriever_one": {"docs": ["doc1", "doc2"]}},
+            {"qa": {"answer": "doc1,doc2,doc3,doc4"}},
+        ],
+        [
+            {"rewrite_query": {"query": "query: what is weather in sf"}},
+            {"analyzer_one": {"query": "analyzed: query: what is weather in sf"}},
+            {"qa": {"answer": ""}},
+            {"retriever_two": {"docs": ["doc3", "doc4"]}},
+            {"retriever_one": {"docs": ["doc1", "doc2"]}},
+            {"qa": {"answer": "doc1,doc2,doc3,doc4"}},
+        ],
+    )
 
     app_w_interrupt = workflow.compile(
         checkpointer=checkpointer,
@@ -3371,6 +3569,59 @@ def test_subgraph_checkpoint_true(
     ]
 
 
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_subgraph_checkpoint_true_interrupt(
+    request: pytest.FixtureRequest, checkpointer_name: str
+) -> None:
+    checkpointer = request.getfixturevalue("checkpointer_" + checkpointer_name)
+
+    # Define subgraph
+    class SubgraphState(TypedDict):
+        # note that none of these keys are shared with the parent graph state
+        bar: str
+        baz: str
+
+    def subgraph_node_1(state: SubgraphState):
+        baz_value = interrupt("Provide baz value")
+        return {"baz": baz_value}
+
+    def subgraph_node_2(state: SubgraphState):
+        return {"bar": state["bar"] + state["baz"]}
+
+    subgraph_builder = StateGraph(SubgraphState)
+    subgraph_builder.add_node(subgraph_node_1)
+    subgraph_builder.add_node(subgraph_node_2)
+    subgraph_builder.add_edge(START, "subgraph_node_1")
+    subgraph_builder.add_edge("subgraph_node_1", "subgraph_node_2")
+    subgraph = subgraph_builder.compile(checkpointer=True)
+
+    class ParentState(TypedDict):
+        foo: str
+
+    def node_1(state: ParentState):
+        return {"foo": "hi! " + state["foo"]}
+
+    def node_2(state: ParentState):
+        response = subgraph.invoke({"bar": state["foo"]})
+        return {"foo": response["bar"]}
+
+    builder = StateGraph(ParentState)
+    builder.add_node("node_1", node_1)
+    builder.add_node("node_2", node_2)
+    builder.add_edge(START, "node_1")
+    builder.add_edge("node_1", "node_2")
+
+    checkpointer = MemorySaver()
+    graph = builder.compile(checkpointer=checkpointer)
+    config = {"configurable": {"thread_id": "1"}}
+
+    assert graph.invoke({"foo": "foo"}, config) == {"foo": "hi! foo"}
+    assert graph.get_state(config, subgraphs=True).tasks[0].state.values == {
+        "bar": "hi! foo"
+    }
+    assert graph.invoke(Command(resume="baz"), config) == {"foo": "hi! foobaz"}
+
+
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
 def test_stream_subgraphs_during_execution(
     request: pytest.FixtureRequest, checkpointer_name: str
@@ -4830,13 +5081,6 @@ def test_parent_command(request: pytest.FixtureRequest, checkpointer_name: str)
             "source": "loop",
             "writes": {
                 "alice": {
-                    "messages": [
-                        _AnyIdHumanMessage(
-                            content="get user name",
-                            additional_kwargs={},
-                            response_metadata={},
-                        ),
-                    ],
                     "user_name": "Meow",
                 }
             },
@@ -6176,90 +6420,6 @@ def test_multiple_subgraphs_checkpointer(
     ]
 
 
-def test_merging_updates_command_parent():
-    # simple reducer
-    def append_unique(left, right):
-        combined = list(left)
-        for item in right:
-            if item in combined:
-                continue
-            else:
-                combined.append(item)
-        return combined
-
-    class State(TypedDict):
-        foo: str
-        bar: Annotated[list[str], append_unique]
-
-    # Define subgraph
-    def subgraph_node_1(state: State):
-        return Command(
-            goto="subgraph_node_2",
-            update={
-                "foo": "foo",
-                "bar": ["subgraph_node_1"],
-            },
-        )
-
-    def subgraph_node_2(state: State):
-        return Command(
-            goto="node_3",
-            update={"bar": ["subgraph_node_2"]},
-            graph=Command.PARENT,
-        )
-
-    subgraph_builder = StateGraph(State)
-    subgraph_builder.add_node(subgraph_node_1)
-    subgraph_builder.add_node(subgraph_node_2)
-    subgraph_builder.add_edge(START, "subgraph_node_1")
-
-    # Define main graph
-    def node_1(state: State):
-        return Command(
-            goto="node_2",
-            update={"bar": ["node_1"]},
-        )
-
-    def node_3(state: State, store):
-        return Command(
-            update={"bar": ["node_3"]},
-        )
-
-    main_builder = StateGraph(State)
-    main_builder.add_node("node_1", node_1)
-    main_builder.add_node("node_2", subgraph_builder.compile())
-    main_builder.add_node("node_3", node_3)
-    main_builder.add_edge(START, "node_1")
-    main_builder.add_edge("node_2", "node_3")
-    main_graph = main_builder.compile()
-
-    assert main_graph.invoke({"foo": ""}) == {
-        "foo": "foo",
-        "bar": ["node_1", "subgraph_node_1", "subgraph_node_2", "node_3"],
-    }
-
-    assert list(
-        main_graph.stream({"foo": ""}, stream_mode="updates", subgraphs=True)
-    ) == [
-        ((), {"node_1": {"bar": ["node_1"]}}),
-        (
-            (AnyStr("node_2:"),),
-            {"subgraph_node_1": {"foo": "foo", "bar": ["subgraph_node_1"]}},
-        ),
-        (
-            (),
-            {
-                "node_2": [
-                    {"foo": "foo"},
-                    {"bar": ["node_1", "subgraph_node_1"]},
-                    {"bar": ["subgraph_node_2"]},
-                ]
-            },
-        ),
-        ((), {"node_3": {"bar": ["node_3"]}}),
-    ]
-
-
 def test_entrypoint_output_schema_with_return_and_save() -> None:
     """Test output schema inference with entrypoint.final."""
 
@@ -6527,3 +6687,194 @@ def test_get_stream_writer() -> None:
             },
         ),
     ]
+
+
+def test_stream_messages_dedupe_inputs() -> None:
+    from langchain_core.messages import AIMessage
+
+    def call_model(state):
+        return {"messages": AIMessage("hi", id="1")}
+
+    def route(state):
+        return Command(goto="node_2", graph=Command.PARENT)
+
+    subgraph = (
+        StateGraph(MessagesState)
+        .add_node(call_model)
+        .add_node(route)
+        .add_edge(START, "call_model")
+        .add_edge("call_model", "route")
+        .compile()
+    )
+
+    graph = (
+        StateGraph(MessagesState)
+        .add_node("node_1", subgraph)
+        .add_node("node_2", lambda state: state)
+        .add_edge(START, "node_1")
+        .compile()
+    )
+
+    chunks = [
+        chunk
+        for ns, chunk in graph.stream(
+            {"messages": "hi"}, stream_mode="messages", subgraphs=True
+        )
+    ]
+
+    assert len(chunks) == 1
+    assert chunks[0][0] == AIMessage("hi", id="1")
+    assert chunks[0][1]["langgraph_node"] == "call_model"
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_stream_messages_dedupe_state(
+    request: pytest.FixtureRequest, checkpointer_name: str
+) -> None:
+    from langchain_core.messages import AIMessage
+
+    checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+    to_emit = [AIMessage("bye", id="1"), AIMessage("bye again", id="2")]
+
+    def call_model(state):
+        return {"messages": to_emit.pop(0)}
+
+    def route(state):
+        return Command(goto="node_2", graph=Command.PARENT)
+
+    subgraph = (
+        StateGraph(MessagesState)
+        .add_node(call_model)
+        .add_node(route)
+        .add_edge(START, "call_model")
+        .add_edge("call_model", "route")
+        .compile()
+    )
+
+    graph = (
+        StateGraph(MessagesState)
+        .add_node("node_1", subgraph)
+        .add_node("node_2", lambda state: state)
+        .add_edge(START, "node_1")
+        .compile(checkpointer=checkpointer)
+    )
+
+    thread1 = {"configurable": {"thread_id": "1"}}
+
+    chunks = [
+        chunk
+        for ns, chunk in graph.stream(
+            {"messages": "hi"}, thread1, stream_mode="messages", subgraphs=True
+        )
+    ]
+
+    assert len(chunks) == 1
+    assert chunks[0][0] == AIMessage("bye", id="1")
+    assert chunks[0][1]["langgraph_node"] == "call_model"
+
+    chunks = [
+        chunk
+        for ns, chunk in graph.stream(
+            {"messages": "hi again"},
+            thread1,
+            stream_mode="messages",
+            subgraphs=True,
+        )
+    ]
+
+    assert len(chunks) == 1
+    assert chunks[0][0] == AIMessage("bye again", id="2")
+    assert chunks[0][1]["langgraph_node"] == "call_model"
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_interrupt_subgraph_reenter_checkpointer_true(
+    request: pytest.FixtureRequest, checkpointer_name: str
+) -> None:
+    checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+
+    class SubgraphState(TypedDict):
+        foo: str
+        bar: str
+
+    class ParentState(TypedDict):
+        foo: str
+        counter: int
+
+    called = []
+    bar_values = []
+
+    def subnode_1(state: SubgraphState):
+        called.append("subnode_1")
+        bar_values.append(state.get("bar"))
+        return {"foo": "subgraph_1"}
+
+    def subnode_2(state: SubgraphState):
+        called.append("subnode_2")
+        value = interrupt("Provide value")
+        value += "baz"
+        return {"foo": "subgraph_2", "bar": value}
+
+    subgraph = (
+        StateGraph(SubgraphState)
+        .add_node(subnode_1)
+        .add_node(subnode_2)
+        .add_edge(START, "subnode_1")
+        .add_edge("subnode_1", "subnode_2")
+        .compile(checkpointer=True)
+    )
+
+    def call_subgraph(state: ParentState):
+        called.append("call_subgraph")
+        return subgraph.invoke(state)
+
+    def node(state: ParentState):
+        called.append("parent")
+        if state["counter"] < 1:
+            return Command(
+                goto="call_subgraph", update={"counter": state["counter"] + 1}
+            )
+
+        return {"foo": state["foo"] + "|" + "parent"}
+
+    parent = (
+        StateGraph(ParentState)
+        .add_node(call_subgraph)
+        .add_node(node)
+        .add_edge(START, "call_subgraph")
+        .add_edge("call_subgraph", "node")
+        .compile(checkpointer=checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+    assert parent.invoke({"foo": "", "counter": 0}, config) == {"foo": "", "counter": 0}
+    assert parent.invoke(Command(resume="bar"), config) == {
+        "foo": "subgraph_2",
+        "counter": 1,
+    }
+    assert parent.invoke(Command(resume="qux"), config) == {
+        "foo": "subgraph_2|parent",
+        "counter": 1,
+    }
+    assert called == [
+        "call_subgraph",
+        "subnode_1",
+        "subnode_2",
+        "call_subgraph",
+        "subnode_2",
+        "parent",
+        "call_subgraph",
+        "subnode_1",
+        "subnode_2",
+        "call_subgraph",
+        "subnode_2",
+        "parent",
+    ]
+
+    # invoke parent again (new turn)
+    assert parent.invoke({"foo": "meow", "counter": 0}, config) == {
+        "foo": "meow",
+        "counter": 0,
+    }
+    # confirm that we preserve the state values from the previous invocation
+    assert bar_values == [None, "barbaz", "quxbaz"]

libs/langgraph/tests/test_pregel_async.py

@@ -6148,13 +6148,6 @@ async def test_parent_command(checkpointer_name: str) -> None:
                 "source": "loop",
                 "writes": {
                     "alice": {
-                        "messages": [
-                            _AnyIdHumanMessage(
-                                content="get user name",
-                                additional_kwargs={},
-                                response_metadata={},
-                            ),
-                        ],
                         "user_name": "Meow",
                     }
                 },
@@ -7282,9 +7275,7 @@ async def test_multiple_subgraphs_mixed_state_graph(
 
 @NEEDS_CONTEXTVARS
 @pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
-async def test_multiple_subgraphs_checkpointer(
-    request: pytest.FixtureRequest, checkpointer_name: str
-) -> None:
+async def test_multiple_subgraphs_checkpointer(checkpointer_name: str) -> None:
     async with awith_checkpointer(checkpointer_name) as checkpointer:
 
         class SubgraphState(TypedDict):
@@ -7513,3 +7504,249 @@ async def test_tags_stream_mode_messages() -> None:
             },
         )
     ]
+
+
+async def test_stream_messages_dedupe_inputs() -> None:
+    from langchain_core.messages import AIMessage
+
+    async def call_model(state):
+        return {"messages": AIMessage("hi", id="1")}
+
+    async def route(state):
+        return Command(goto="node_2", graph=Command.PARENT)
+
+    subgraph = (
+        StateGraph(MessagesState)
+        .add_node(call_model)
+        .add_node(route)
+        .add_edge(START, "call_model")
+        .add_edge("call_model", "route")
+        .compile()
+    )
+
+    graph = (
+        StateGraph(MessagesState)
+        .add_node("node_1", subgraph)
+        .add_node("node_2", lambda state: state)
+        .add_edge(START, "node_1")
+        .compile()
+    )
+
+    chunks = [
+        chunk
+        async for ns, chunk in graph.astream(
+            {"messages": "hi"}, stream_mode="messages", subgraphs=True
+        )
+    ]
+
+    assert len(chunks) == 1
+    assert chunks[0][0] == AIMessage("hi", id="1")
+    assert chunks[0][1]["langgraph_node"] == "call_model"
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
+async def test_stream_messages_dedupe_state(checkpointer_name: str) -> None:
+    async with awith_checkpointer(checkpointer_name) as checkpointer:
+        from langchain_core.messages import AIMessage
+
+        to_emit = [AIMessage("bye", id="1"), AIMessage("bye again", id="2")]
+
+        async def call_model(state):
+            return {"messages": to_emit.pop(0)}
+
+        async def route(state):
+            return Command(goto="node_2", graph=Command.PARENT)
+
+        subgraph = (
+            StateGraph(MessagesState)
+            .add_node(call_model)
+            .add_node(route)
+            .add_edge(START, "call_model")
+            .add_edge("call_model", "route")
+            .compile()
+        )
+
+        graph = (
+            StateGraph(MessagesState)
+            .add_node("node_1", subgraph)
+            .add_node("node_2", lambda state: state)
+            .add_edge(START, "node_1")
+            .compile(checkpointer=checkpointer)
+        )
+
+        thread1 = {"configurable": {"thread_id": "1"}}
+
+        chunks = [
+            chunk
+            async for ns, chunk in graph.astream(
+                {"messages": "hi"}, thread1, stream_mode="messages", subgraphs=True
+            )
+        ]
+
+        assert len(chunks) == 1
+        assert chunks[0][0] == AIMessage("bye", id="1")
+        assert chunks[0][1]["langgraph_node"] == "call_model"
+
+        chunks = [
+            chunk
+            async for ns, chunk in graph.astream(
+                {"messages": "hi again"},
+                thread1,
+                stream_mode="messages",
+                subgraphs=True,
+            )
+        ]
+
+        assert len(chunks) == 1
+        assert chunks[0][0] == AIMessage("bye again", id="2")
+        assert chunks[0][1]["langgraph_node"] == "call_model"
+
+
+@NEEDS_CONTEXTVARS
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
+async def test_interrupt_subgraph_reenter_checkpointer_true(
+    checkpointer_name: str,
+) -> None:
+    async with awith_checkpointer(checkpointer_name) as checkpointer:
+
+        class SubgraphState(TypedDict):
+            foo: str
+            bar: str
+
+        class ParentState(TypedDict):
+            foo: str
+            counter: int
+
+        called = []
+        bar_values = []
+
+        async def subnode_1(state: SubgraphState):
+            called.append("subnode_1")
+            bar_values.append(state.get("bar"))
+            return {"foo": "subgraph_1"}
+
+        async def subnode_2(state: SubgraphState):
+            called.append("subnode_2")
+            value = interrupt("Provide value")
+            value += "baz"
+            return {"foo": "subgraph_2", "bar": value}
+
+        subgraph = (
+            StateGraph(SubgraphState)
+            .add_node(subnode_1)
+            .add_node(subnode_2)
+            .add_edge(START, "subnode_1")
+            .add_edge("subnode_1", "subnode_2")
+            .compile(checkpointer=True)
+        )
+
+        async def call_subgraph(state: ParentState):
+            called.append("call_subgraph")
+            return await subgraph.ainvoke(state)
+
+        async def node(state: ParentState):
+            called.append("parent")
+            if state["counter"] < 1:
+                return Command(
+                    goto="call_subgraph", update={"counter": state["counter"] + 1}
+                )
+
+            return {"foo": state["foo"] + "|" + "parent"}
+
+        parent = (
+            StateGraph(ParentState)
+            .add_node(call_subgraph)
+            .add_node(node)
+            .add_edge(START, "call_subgraph")
+            .add_edge("call_subgraph", "node")
+            .compile(checkpointer=checkpointer)
+        )
+
+        config = {"configurable": {"thread_id": "1"}}
+        assert await parent.ainvoke({"foo": "", "counter": 0}, config) == {
+            "foo": "",
+            "counter": 0,
+        }
+        assert await parent.ainvoke(Command(resume="bar"), config) == {
+            "foo": "subgraph_2",
+            "counter": 1,
+        }
+        assert await parent.ainvoke(Command(resume="qux"), config) == {
+            "foo": "subgraph_2|parent",
+            "counter": 1,
+        }
+        assert called == [
+            "call_subgraph",
+            "subnode_1",
+            "subnode_2",
+            "call_subgraph",
+            "subnode_2",
+            "parent",
+            "call_subgraph",
+            "subnode_1",
+            "subnode_2",
+            "call_subgraph",
+            "subnode_2",
+            "parent",
+        ]
+
+        # invoke parent again (new turn)
+        assert await parent.ainvoke({"foo": "meow", "counter": 0}, config) == {
+            "foo": "meow",
+            "counter": 0,
+        }
+        # 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_pydantic.py

@@ -0,0 +1,43 @@
+import sys
+import typing
+
+import pydantic
+import typing_extensions
+
+from langgraph.utils.pydantic import is_supported_by_pydantic
+
+
+def test_is_supported_by_pydantic() -> None:
+    """Test if types are supported by pydantic."""
+
+    class TypedDictExtensions(typing_extensions.TypedDict):
+        x: int
+
+    assert is_supported_by_pydantic(TypedDictExtensions) is True
+
+    class VanillaClass:
+        x: int
+
+    assert is_supported_by_pydantic(VanillaClass) is False
+
+    class BuiltinTypedDict(typing.TypedDict):  # noqa: TID251
+        x: int
+
+    if sys.version_info >= (3, 12):
+        assert is_supported_by_pydantic(BuiltinTypedDict) is True
+    else:
+        assert is_supported_by_pydantic(BuiltinTypedDict) is False
+
+    class PydanticModel(pydantic.BaseModel):
+        x: int
+
+    assert is_supported_by_pydantic(PydanticModel) is True
+
+    if hasattr(pydantic, "v1"):
+
+        class PydanticModelV1(pydantic.v1.BaseModel):
+            x: int
+
+        assert is_supported_by_pydantic(PydanticModelV1) is False
+
+    assert is_supported_by_pydantic(int) is False

libs/langgraph/tests/test_state.py

@@ -1,4 +1,5 @@
 import inspect
+import operator
 import warnings
 from dataclasses import dataclass, field
 from typing import Annotated as Annotated2
@@ -328,3 +329,74 @@ 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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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/prebuilt/Makefile

@@ -0,0 +1,78 @@
+.PHONY: all format lint test test_watch integration_tests spell_check spell_fix benchmark profile
+
+# Default target executed when no arguments are given to make.
+all: help
+
+######################
+# TESTING AND COVERAGE
+######################
+
+start-postgres:
+	docker compose -f tests/compose-postgres.yml up -V --force-recreate --wait --remove-orphans
+
+stop-postgres:
+	docker compose -f tests/compose-postgres.yml down -v
+
+TEST ?= .
+
+test:
+	make start-postgres && poetry run pytest $(TEST); \
+	EXIT_CODE=$$?; \
+	make stop-postgres; \
+	exit $$EXIT_CODE
+
+test_watch:
+	make start-postgres && poetry run ptw $(TEST); \
+	EXIT_CODE=$$?; \
+	make stop-postgres; \
+	exit $$EXIT_CODE
+
+######################
+# LINTING AND FORMATTING
+######################
+
+# Define a variable for Python and notebook files.
+PYTHON_FILES=.
+MYPY_CACHE=.mypy_cache
+lint format: PYTHON_FILES=.
+lint_diff format_diff: PYTHON_FILES=$(shell git diff --name-only --relative --diff-filter=d main . | grep -E '\.py$$|\.ipynb$$')
+lint_package: PYTHON_FILES=langgraph
+lint_tests: PYTHON_FILES=tests
+lint_tests: MYPY_CACHE=.mypy_cache_test
+
+lint lint_diff lint_package lint_tests:
+	poetry run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff check --select I $(PYTHON_FILES)
+	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || poetry run mypy langgraph --cache-dir $(MYPY_CACHE)
+
+format format_diff:
+	poetry run ruff format $(PYTHON_FILES)
+	poetry run ruff check --select I --fix $(PYTHON_FILES)
+
+spell_check:
+	poetry run codespell --toml pyproject.toml
+
+spell_fix:
+	poetry run codespell --toml pyproject.toml -w
+
+
+######################
+# HELP
+######################
+
+help:
+	@echo '===================='
+	@echo '-- DOCUMENTATION --'
+	
+	@echo '-- LINTING --'
+	@echo 'format                       - run code formatters'
+	@echo 'lint                         - run linters'
+	@echo 'spell_check               	- run codespell on the project'
+	@echo 'spell_fix               		- run codespell on the project and fix the errors'
+	@echo '-- TESTS --'
+	@echo 'coverage                     - run unit tests and generate coverage report'
+	@echo 'test                         - run unit tests'
+	@echo 'test TEST_FILE=<test_file>   - run all tests in file'
+	@echo 'test_watch                   - run unit tests in watch mode'